Snap for 11028996 from 8a6c7d4f79add19167d8ea37e85ec09678738f19 to mainline-permission-releaseaml_per_341614000aml_per_341510010aml_per_341410020aml_per_341311000android14-mainline-permission-release

Change-Id: I7de28721f72ccaa018beec6519bd67bf45bcdac6

28 files changed, 75089 insertions, 18276 deletions

diff --git a/stream-servers/vulkan/VkDecoder.cpp b/stream-servers/vulkan/VkDecoder.cpp
index 869d8a76..4cc483e5 100644
--- a/stream-servers/vulkan/VkDecoder.cpp
+++ b/stream-servers/vulkan/VkDecoder.cpp
@@ -15,8 +15,8 @@
 
 // Autogenerated module VkDecoder
 //
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (impl) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -52,7 +52,6 @@
 #include "host-common/logging.h"
 #include "stream-servers/FrameBuffer.h"
 #include "stream-servers/IOStream.h"
-
 #define MAX_PACKET_LENGTH (400 * 1024 * 1024)  // 400MB
 
 namespace gfxstream {
@@ -163,7 +162,8 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             }
         }
 
-        std::atomic<uint32_t>* seqnoPtr = processResources->getSequenceNumberPtr();
+        std::atomic<uint32_t>* seqnoPtr =
+            processResources ? processResources->getSequenceNumberPtr() : nullptr;
 
         if (queueSubmitWithCommandsEnabled &&
             ((opcode >= OP_vkFirst && opcode < OP_vkLast) ||
@@ -1911,6 +1911,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                         uint8_t* targetRange = hostPtr + offset;
                         memcpy(targetRange, *readStreamPtrPtr, readStream);
                         *readStreamPtrPtr += readStream;
+                        packetLen += 8 + readStream;
                     }
                 }
                 VkResult vkFlushMappedMemoryRanges_VkResult_return = (VkResult)0;
@@ -11290,6 +11291,1853 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 break;
             }
 #endif
+#ifdef VK_VERSION_1_3
+            case OP_vkGetPhysicalDeviceToolProperties: {
+                android::base::beginTrace("vkGetPhysicalDeviceToolProperties decode");
+                VkPhysicalDevice physicalDevice;
+                uint32_t* pToolCount;
+                VkPhysicalDeviceToolProperties* pToolProperties;
+                // Begin non wrapped dispatchable handle unboxing for physicalDevice;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkPhysicalDevice*)&physicalDevice =
+                    (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
+                auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
+                auto vk = dispatch_VkPhysicalDevice(physicalDevice);
+                // End manual dispatchable handle unboxing for physicalDevice;
+                // Begin manual dispatchable handle unboxing for pToolCount;
+                vkReadStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                memcpy((uint32_t**)&pToolCount, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pToolCount);
+                *readStreamPtrPtr += 8;
+                if (pToolCount) {
+                    vkReadStream->alloc((void**)&pToolCount, sizeof(uint32_t));
+                    memcpy((uint32_t*)pToolCount, *readStreamPtrPtr, sizeof(uint32_t));
+                    *readStreamPtrPtr += sizeof(uint32_t);
+                }
+                // Begin manual dispatchable handle unboxing for pToolProperties;
+                vkReadStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                memcpy((VkPhysicalDeviceToolProperties**)&pToolProperties, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pToolProperties);
+                *readStreamPtrPtr += 8;
+                if (pToolProperties) {
+                    vkReadStream->alloc((void**)&pToolProperties,
+                                        (*(pToolCount)) * sizeof(VkPhysicalDeviceToolProperties));
+                    for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
+                        reservedunmarshal_VkPhysicalDeviceToolProperties(
+                            vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                            (VkPhysicalDeviceToolProperties*)(pToolProperties + i),
+                            readStreamPtrPtr);
+                    }
+                }
+                if (pToolCount) {
+                    if (pToolProperties) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
+                            transform_tohost_VkPhysicalDeviceToolProperties(
+                                m_state, (VkPhysicalDeviceToolProperties*)(pToolProperties + i));
+                        }
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkGetPhysicalDeviceToolProperties 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)physicalDevice,
+                        (unsigned long long)pToolCount, (unsigned long long)pToolProperties);
+                }
+                VkResult vkGetPhysicalDeviceToolProperties_VkResult_return = (VkResult)0;
+                vkGetPhysicalDeviceToolProperties_VkResult_return =
+                    vk->vkGetPhysicalDeviceToolProperties(unboxed_physicalDevice, pToolCount,
+                                                          pToolProperties);
+                if ((vkGetPhysicalDeviceToolProperties_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkGetPhysicalDeviceToolProperties_VkResult_return,
+                                             opcode, context);
+                vkStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pToolCount;
+                vkStream->putBe64(cgen_var_3);
+                if (pToolCount) {
+                    vkStream->write((uint32_t*)pToolCount, sizeof(uint32_t));
+                }
+                if (pToolCount) {
+                    if (pToolProperties) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
+                            transform_fromhost_VkPhysicalDeviceToolProperties(
+                                m_state, (VkPhysicalDeviceToolProperties*)(pToolProperties + i));
+                        }
+                    }
+                }
+                // WARNING PTR CHECK
+                uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pToolProperties;
+                vkStream->putBe64(cgen_var_4);
+                if (pToolProperties) {
+                    if (pToolCount) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
+                            marshal_VkPhysicalDeviceToolProperties(
+                                vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                (VkPhysicalDeviceToolProperties*)(pToolProperties + i));
+                        }
+                    }
+                }
+                vkStream->write(&vkGetPhysicalDeviceToolProperties_VkResult_return,
+                                sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetPhysicalDeviceToolProperties(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkGetPhysicalDeviceToolProperties_VkResult_return, physicalDevice,
+                        pToolCount, pToolProperties);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCreatePrivateDataSlot: {
+                android::base::beginTrace("vkCreatePrivateDataSlot decode");
+                VkDevice device;
+                const VkPrivateDataSlotCreateInfo* pCreateInfo;
+                const VkAllocationCallbacks* pAllocator;
+                VkPrivateDataSlot* pPrivateDataSlot;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pCreateInfo,
+                                    sizeof(const VkPrivateDataSlotCreateInfo));
+                reservedunmarshal_VkPrivateDataSlotCreateInfo(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkPrivateDataSlotCreateInfo*)(pCreateInfo), readStreamPtrPtr);
+                // WARNING PTR CHECK
+                memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pAllocator);
+                *readStreamPtrPtr += 8;
+                if (pAllocator) {
+                    vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
+                    reservedunmarshal_VkAllocationCallbacks(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
+                }
+                // Begin manual dispatchable handle unboxing for pPrivateDataSlot;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pPrivateDataSlot, sizeof(VkPrivateDataSlot));
+                memcpy((VkPrivateDataSlot*)&(*pPrivateDataSlot), (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&(*pPrivateDataSlot));
+                *readStreamPtrPtr += 8;
+                if (pCreateInfo) {
+                    transform_tohost_VkPrivateDataSlotCreateInfo(
+                        m_state, (VkPrivateDataSlotCreateInfo*)(pCreateInfo));
+                }
+                if (pAllocator) {
+                    transform_tohost_VkAllocationCallbacks(m_state,
+                                                           (VkAllocationCallbacks*)(pAllocator));
+                }
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkCreatePrivateDataSlot 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
+                        (unsigned long long)pAllocator, (unsigned long long)pPrivateDataSlot);
+                }
+                VkResult vkCreatePrivateDataSlot_VkResult_return = (VkResult)0;
+                vkCreatePrivateDataSlot_VkResult_return = vk->vkCreatePrivateDataSlot(
+                    unboxed_device, pCreateInfo, pAllocator, pPrivateDataSlot);
+                if ((vkCreatePrivateDataSlot_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkCreatePrivateDataSlot_VkResult_return, opcode,
+                                             context);
+                vkStream->unsetHandleMapping();
+                uint64_t cgen_var_3 = (uint64_t)(*pPrivateDataSlot);
+                vkStream->putBe64(cgen_var_3);
+                vkStream->write(&vkCreatePrivateDataSlot_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCreatePrivateDataSlot(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkCreatePrivateDataSlot_VkResult_return, device, pCreateInfo, pAllocator,
+                        pPrivateDataSlot);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkDestroyPrivateDataSlot: {
+                android::base::beginTrace("vkDestroyPrivateDataSlot decode");
+                VkDevice device;
+                VkPrivateDataSlot privateDataSlot;
+                const VkAllocationCallbacks* pAllocator;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((VkPrivateDataSlot*)&privateDataSlot, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&privateDataSlot);
+                *readStreamPtrPtr += 8;
+                // WARNING PTR CHECK
+                memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pAllocator);
+                *readStreamPtrPtr += 8;
+                if (pAllocator) {
+                    vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
+                    reservedunmarshal_VkAllocationCallbacks(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
+                }
+                if (pAllocator) {
+                    transform_tohost_VkAllocationCallbacks(m_state,
+                                                           (VkAllocationCallbacks*)(pAllocator));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkDestroyPrivateDataSlot 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device,
+                            (unsigned long long)privateDataSlot, (unsigned long long)pAllocator);
+                }
+                vk->vkDestroyPrivateDataSlot(unboxed_device, privateDataSlot, pAllocator);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkDestroyPrivateDataSlot(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, privateDataSlot,
+                        pAllocator);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkSetPrivateData: {
+                android::base::beginTrace("vkSetPrivateData decode");
+                VkDevice device;
+                VkObjectType objectType;
+                uint64_t objectHandle;
+                VkPrivateDataSlot privateDataSlot;
+                uint64_t data;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((VkObjectType*)&objectType, *readStreamPtrPtr, sizeof(VkObjectType));
+                *readStreamPtrPtr += sizeof(VkObjectType);
+                memcpy((uint64_t*)&objectHandle, *readStreamPtrPtr, sizeof(uint64_t));
+                *readStreamPtrPtr += sizeof(uint64_t);
+                memcpy((VkPrivateDataSlot*)&privateDataSlot, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&privateDataSlot);
+                *readStreamPtrPtr += 8;
+                memcpy((uint64_t*)&data, *readStreamPtrPtr, sizeof(uint64_t));
+                *readStreamPtrPtr += sizeof(uint64_t);
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkSetPrivateData 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)device, (unsigned long long)objectType,
+                        (unsigned long long)objectHandle, (unsigned long long)privateDataSlot,
+                        (unsigned long long)data);
+                }
+                VkResult vkSetPrivateData_VkResult_return = (VkResult)0;
+                vkSetPrivateData_VkResult_return = vk->vkSetPrivateData(
+                    unboxed_device, objectType, objectHandle, privateDataSlot, data);
+                if ((vkSetPrivateData_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkSetPrivateData_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                vkStream->write(&vkSetPrivateData_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkSetPrivateData(snapshotTraceBegin, snapshotTraceBytes,
+                                                          &m_pool, vkSetPrivateData_VkResult_return,
+                                                          device, objectType, objectHandle,
+                                                          privateDataSlot, data);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetPrivateData: {
+                android::base::beginTrace("vkGetPrivateData decode");
+                VkDevice device;
+                VkObjectType objectType;
+                uint64_t objectHandle;
+                VkPrivateDataSlot privateDataSlot;
+                uint64_t* pData;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((VkObjectType*)&objectType, *readStreamPtrPtr, sizeof(VkObjectType));
+                *readStreamPtrPtr += sizeof(VkObjectType);
+                memcpy((uint64_t*)&objectHandle, *readStreamPtrPtr, sizeof(uint64_t));
+                *readStreamPtrPtr += sizeof(uint64_t);
+                memcpy((VkPrivateDataSlot*)&privateDataSlot, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&privateDataSlot);
+                *readStreamPtrPtr += 8;
+                // Begin manual dispatchable handle unboxing for pData;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pData, sizeof(uint64_t));
+                memcpy((uint64_t*)pData, *readStreamPtrPtr, sizeof(uint64_t));
+                *readStreamPtrPtr += sizeof(uint64_t);
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkGetPrivateData 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)device, (unsigned long long)objectType,
+                        (unsigned long long)objectHandle, (unsigned long long)privateDataSlot,
+                        (unsigned long long)pData);
+                }
+                vk->vkGetPrivateData(unboxed_device, objectType, objectHandle, privateDataSlot,
+                                     pData);
+                vkStream->unsetHandleMapping();
+                vkStream->write((uint64_t*)pData, sizeof(uint64_t));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetPrivateData(snapshotTraceBegin, snapshotTraceBytes,
+                                                          &m_pool, device, objectType, objectHandle,
+                                                          privateDataSlot, pData);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetEvent2: {
+                android::base::beginTrace("vkCmdSetEvent2 decode");
+                VkCommandBuffer commandBuffer;
+                VkEvent event;
+                const VkDependencyInfo* pDependencyInfo;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
+                vkReadStream->alloc((void**)&pDependencyInfo, sizeof(const VkDependencyInfo));
+                reservedunmarshal_VkDependencyInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkDependencyInfo*)(pDependencyInfo),
+                                                   readStreamPtrPtr);
+                if (pDependencyInfo) {
+                    transform_tohost_VkDependencyInfo(m_state,
+                                                      (VkDependencyInfo*)(pDependencyInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetEvent2 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer, (unsigned long long)event,
+                            (unsigned long long)pDependencyInfo);
+                }
+                vk->vkCmdSetEvent2(unboxed_commandBuffer, event, pDependencyInfo);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetEvent2(snapshotTraceBegin, snapshotTraceBytes,
+                                                        &m_pool, commandBuffer, event,
+                                                        pDependencyInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdResetEvent2: {
+                android::base::beginTrace("vkCmdResetEvent2 decode");
+                VkCommandBuffer commandBuffer;
+                VkEvent event;
+                VkPipelineStageFlags2 stageMask;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
+                memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlags2));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdResetEvent2 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer, (unsigned long long)event,
+                            (unsigned long long)stageMask);
+                }
+                vk->vkCmdResetEvent2(unboxed_commandBuffer, event, stageMask);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdResetEvent2(snapshotTraceBegin, snapshotTraceBytes,
+                                                          &m_pool, commandBuffer, event, stageMask);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdWaitEvents2: {
+                android::base::beginTrace("vkCmdWaitEvents2 decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t eventCount;
+                const VkEvent* pEvents;
+                const VkDependencyInfo* pDependencyInfos;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
+                if (((eventCount))) {
+                    uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
+                    *readStreamPtrPtr += 8 * ((eventCount));
+                    for (uint32_t k = 0; k < ((eventCount)); ++k) {
+                        uint64_t tmpval;
+                        memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
+                        *(((VkEvent*)pEvents) + k) = (VkEvent)unbox_VkEvent((VkEvent)tmpval);
+                    }
+                }
+                vkReadStream->alloc((void**)&pDependencyInfos,
+                                    ((eventCount)) * sizeof(const VkDependencyInfo));
+                for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
+                    reservedunmarshal_VkDependencyInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                       (VkDependencyInfo*)(pDependencyInfos + i),
+                                                       readStreamPtrPtr);
+                }
+                if (pDependencyInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
+                        transform_tohost_VkDependencyInfo(
+                            m_state, (VkDependencyInfo*)(pDependencyInfos + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(
+                        stderr, "stream %p: call vkCmdWaitEvents2 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)commandBuffer, (unsigned long long)eventCount,
+                        (unsigned long long)pEvents, (unsigned long long)pDependencyInfos);
+                }
+                vk->vkCmdWaitEvents2(unboxed_commandBuffer, eventCount, pEvents, pDependencyInfos);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdWaitEvents2(snapshotTraceBegin, snapshotTraceBytes,
+                                                          &m_pool, commandBuffer, eventCount,
+                                                          pEvents, pDependencyInfos);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdPipelineBarrier2: {
+                android::base::beginTrace("vkCmdPipelineBarrier2 decode");
+                VkCommandBuffer commandBuffer;
+                const VkDependencyInfo* pDependencyInfo;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                vkReadStream->alloc((void**)&pDependencyInfo, sizeof(const VkDependencyInfo));
+                reservedunmarshal_VkDependencyInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkDependencyInfo*)(pDependencyInfo),
+                                                   readStreamPtrPtr);
+                if (pDependencyInfo) {
+                    transform_tohost_VkDependencyInfo(m_state,
+                                                      (VkDependencyInfo*)(pDependencyInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdPipelineBarrier2 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)pDependencyInfo);
+                }
+                vk->vkCmdPipelineBarrier2(unboxed_commandBuffer, pDependencyInfo);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdPipelineBarrier2(snapshotTraceBegin,
+                                                               snapshotTraceBytes, &m_pool,
+                                                               commandBuffer, pDependencyInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdWriteTimestamp2: {
+                android::base::beginTrace("vkCmdWriteTimestamp2 decode");
+                VkCommandBuffer commandBuffer;
+                VkPipelineStageFlags2 stage;
+                VkQueryPool queryPool;
+                uint32_t query;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlags2));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkQueryPool*)&queryPool =
+                    (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
+                memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdWriteTimestamp2 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer, (unsigned long long)stage,
+                            (unsigned long long)queryPool, (unsigned long long)query);
+                }
+                vk->vkCmdWriteTimestamp2(unboxed_commandBuffer, stage, queryPool, query);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdWriteTimestamp2(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, stage,
+                        queryPool, query);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkQueueSubmit2: {
+                android::base::beginTrace("vkQueueSubmit2 decode");
+                VkQueue queue;
+                uint32_t submitCount;
+                const VkSubmitInfo2* pSubmits;
+                VkFence fence;
+                // Begin non wrapped dispatchable handle unboxing for queue;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
+                auto unboxed_queue = unbox_VkQueue(queue);
+                auto vk = dispatch_VkQueue(queue);
+                // End manual dispatchable handle unboxing for queue;
+                memcpy((uint32_t*)&submitCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pSubmits,
+                                    ((submitCount)) * sizeof(const VkSubmitInfo2));
+                for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
+                    reservedunmarshal_VkSubmitInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                    (VkSubmitInfo2*)(pSubmits + i),
+                                                    readStreamPtrPtr);
+                }
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkFence*)&fence = (VkFence)unbox_VkFence((VkFence)(*&cgen_var_1));
+                if (pSubmits) {
+                    for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
+                        transform_tohost_VkSubmitInfo2(m_state, (VkSubmitInfo2*)(pSubmits + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkQueueSubmit2 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)queue, (unsigned long long)submitCount,
+                            (unsigned long long)pSubmits, (unsigned long long)fence);
+                }
+                VkResult vkQueueSubmit2_VkResult_return = (VkResult)0;
+                vkQueueSubmit2_VkResult_return =
+                    vk->vkQueueSubmit2(unboxed_queue, submitCount, pSubmits, fence);
+                if ((vkQueueSubmit2_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkQueueSubmit2_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                vkStream->write(&vkQueueSubmit2_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkQueueSubmit2(snapshotTraceBegin, snapshotTraceBytes,
+                                                        &m_pool, vkQueueSubmit2_VkResult_return,
+                                                        queue, submitCount, pSubmits, fence);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyBuffer2: {
+                android::base::beginTrace("vkCmdCopyBuffer2 decode");
+                VkCommandBuffer commandBuffer;
+                const VkCopyBufferInfo2* pCopyBufferInfo;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                vkReadStream->alloc((void**)&pCopyBufferInfo, sizeof(const VkCopyBufferInfo2));
+                reservedunmarshal_VkCopyBufferInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                    (VkCopyBufferInfo2*)(pCopyBufferInfo),
+                                                    readStreamPtrPtr);
+                if (pCopyBufferInfo) {
+                    transform_tohost_VkCopyBufferInfo2(m_state,
+                                                       (VkCopyBufferInfo2*)(pCopyBufferInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdCopyBuffer2 0x%llx 0x%llx \n", ioStream,
+                            (unsigned long long)commandBuffer, (unsigned long long)pCopyBufferInfo);
+                }
+                vk->vkCmdCopyBuffer2(unboxed_commandBuffer, pCopyBufferInfo);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdCopyBuffer2(snapshotTraceBegin, snapshotTraceBytes,
+                                                          &m_pool, commandBuffer, pCopyBufferInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyImage2: {
+                android::base::beginTrace("vkCmdCopyImage2 decode");
+                VkCommandBuffer commandBuffer;
+                const VkCopyImageInfo2* pCopyImageInfo;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                vkReadStream->alloc((void**)&pCopyImageInfo, sizeof(const VkCopyImageInfo2));
+                reservedunmarshal_VkCopyImageInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkCopyImageInfo2*)(pCopyImageInfo),
+                                                   readStreamPtrPtr);
+                if (pCopyImageInfo) {
+                    transform_tohost_VkCopyImageInfo2(m_state, (VkCopyImageInfo2*)(pCopyImageInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdCopyImage2 0x%llx 0x%llx \n", ioStream,
+                            (unsigned long long)commandBuffer, (unsigned long long)pCopyImageInfo);
+                }
+                vk->vkCmdCopyImage2(unboxed_commandBuffer, pCopyImageInfo);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdCopyImage2(snapshotTraceBegin, snapshotTraceBytes,
+                                                         &m_pool, commandBuffer, pCopyImageInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyBufferToImage2: {
+                android::base::beginTrace("vkCmdCopyBufferToImage2 decode");
+                VkCommandBuffer commandBuffer;
+                const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                vkReadStream->alloc((void**)&pCopyBufferToImageInfo,
+                                    sizeof(const VkCopyBufferToImageInfo2));
+                reservedunmarshal_VkCopyBufferToImageInfo2(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
+                if (pCopyBufferToImageInfo) {
+                    transform_tohost_VkCopyBufferToImageInfo2(
+                        m_state, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdCopyBufferToImage2 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)pCopyBufferToImageInfo);
+                }
+                vk->vkCmdCopyBufferToImage2(unboxed_commandBuffer, pCopyBufferToImageInfo);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdCopyBufferToImage2(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        pCopyBufferToImageInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyImageToBuffer2: {
+                android::base::beginTrace("vkCmdCopyImageToBuffer2 decode");
+                VkCommandBuffer commandBuffer;
+                const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                vkReadStream->alloc((void**)&pCopyImageToBufferInfo,
+                                    sizeof(const VkCopyImageToBufferInfo2));
+                reservedunmarshal_VkCopyImageToBufferInfo2(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
+                if (pCopyImageToBufferInfo) {
+                    transform_tohost_VkCopyImageToBufferInfo2(
+                        m_state, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdCopyImageToBuffer2 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)pCopyImageToBufferInfo);
+                }
+                vk->vkCmdCopyImageToBuffer2(unboxed_commandBuffer, pCopyImageToBufferInfo);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdCopyImageToBuffer2(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        pCopyImageToBufferInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBlitImage2: {
+                android::base::beginTrace("vkCmdBlitImage2 decode");
+                VkCommandBuffer commandBuffer;
+                const VkBlitImageInfo2* pBlitImageInfo;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                vkReadStream->alloc((void**)&pBlitImageInfo, sizeof(const VkBlitImageInfo2));
+                reservedunmarshal_VkBlitImageInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkBlitImageInfo2*)(pBlitImageInfo),
+                                                   readStreamPtrPtr);
+                if (pBlitImageInfo) {
+                    transform_tohost_VkBlitImageInfo2(m_state, (VkBlitImageInfo2*)(pBlitImageInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdBlitImage2 0x%llx 0x%llx \n", ioStream,
+                            (unsigned long long)commandBuffer, (unsigned long long)pBlitImageInfo);
+                }
+                vk->vkCmdBlitImage2(unboxed_commandBuffer, pBlitImageInfo);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdBlitImage2(snapshotTraceBegin, snapshotTraceBytes,
+                                                         &m_pool, commandBuffer, pBlitImageInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdResolveImage2: {
+                android::base::beginTrace("vkCmdResolveImage2 decode");
+                VkCommandBuffer commandBuffer;
+                const VkResolveImageInfo2* pResolveImageInfo;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                vkReadStream->alloc((void**)&pResolveImageInfo, sizeof(const VkResolveImageInfo2));
+                reservedunmarshal_VkResolveImageInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                      (VkResolveImageInfo2*)(pResolveImageInfo),
+                                                      readStreamPtrPtr);
+                if (pResolveImageInfo) {
+                    transform_tohost_VkResolveImageInfo2(m_state,
+                                                         (VkResolveImageInfo2*)(pResolveImageInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdResolveImage2 0x%llx 0x%llx \n", ioStream,
+                            (unsigned long long)commandBuffer,
+                            (unsigned long long)pResolveImageInfo);
+                }
+                vk->vkCmdResolveImage2(unboxed_commandBuffer, pResolveImageInfo);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdResolveImage2(snapshotTraceBegin, snapshotTraceBytes,
+                                                            &m_pool, commandBuffer,
+                                                            pResolveImageInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBeginRendering: {
+                android::base::beginTrace("vkCmdBeginRendering decode");
+                VkCommandBuffer commandBuffer;
+                const VkRenderingInfo* pRenderingInfo;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                vkReadStream->alloc((void**)&pRenderingInfo, sizeof(const VkRenderingInfo));
+                reservedunmarshal_VkRenderingInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                  (VkRenderingInfo*)(pRenderingInfo),
+                                                  readStreamPtrPtr);
+                if (pRenderingInfo) {
+                    transform_tohost_VkRenderingInfo(m_state, (VkRenderingInfo*)(pRenderingInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdBeginRendering 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)pRenderingInfo);
+                }
+                vk->vkCmdBeginRendering(unboxed_commandBuffer, pRenderingInfo);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdBeginRendering(snapshotTraceBegin, snapshotTraceBytes,
+                                                             &m_pool, commandBuffer,
+                                                             pRenderingInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdEndRendering: {
+                android::base::beginTrace("vkCmdEndRendering decode");
+                VkCommandBuffer commandBuffer;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdEndRendering 0x%llx \n", ioStream,
+                            (unsigned long long)commandBuffer);
+                }
+                vk->vkCmdEndRendering(unboxed_commandBuffer);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdEndRendering(snapshotTraceBegin, snapshotTraceBytes,
+                                                           &m_pool, commandBuffer);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCullMode: {
+                android::base::beginTrace("vkCmdSetCullMode decode");
+                VkCommandBuffer commandBuffer;
+                VkCullModeFlags cullMode;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkCullModeFlags*)&cullMode, *readStreamPtrPtr, sizeof(VkCullModeFlags));
+                *readStreamPtrPtr += sizeof(VkCullModeFlags);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetCullMode 0x%llx 0x%llx \n", ioStream,
+                            (unsigned long long)commandBuffer, (unsigned long long)cullMode);
+                }
+                vk->vkCmdSetCullMode(unboxed_commandBuffer, cullMode);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetCullMode(snapshotTraceBegin, snapshotTraceBytes,
+                                                          &m_pool, commandBuffer, cullMode);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetFrontFace: {
+                android::base::beginTrace("vkCmdSetFrontFace decode");
+                VkCommandBuffer commandBuffer;
+                VkFrontFace frontFace;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkFrontFace*)&frontFace, *readStreamPtrPtr, sizeof(VkFrontFace));
+                *readStreamPtrPtr += sizeof(VkFrontFace);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetFrontFace 0x%llx 0x%llx \n", ioStream,
+                            (unsigned long long)commandBuffer, (unsigned long long)frontFace);
+                }
+                vk->vkCmdSetFrontFace(unboxed_commandBuffer, frontFace);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetFrontFace(snapshotTraceBegin, snapshotTraceBytes,
+                                                           &m_pool, commandBuffer, frontFace);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetPrimitiveTopology: {
+                android::base::beginTrace("vkCmdSetPrimitiveTopology decode");
+                VkCommandBuffer commandBuffer;
+                VkPrimitiveTopology primitiveTopology;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkPrimitiveTopology*)&primitiveTopology, *readStreamPtrPtr,
+                       sizeof(VkPrimitiveTopology));
+                *readStreamPtrPtr += sizeof(VkPrimitiveTopology);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetPrimitiveTopology 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)primitiveTopology);
+                }
+                vk->vkCmdSetPrimitiveTopology(unboxed_commandBuffer, primitiveTopology);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetPrimitiveTopology(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        primitiveTopology);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetViewportWithCount: {
+                android::base::beginTrace("vkCmdSetViewportWithCount decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t viewportCount;
+                const VkViewport* pViewports;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pViewports,
+                                    ((viewportCount)) * sizeof(const VkViewport));
+                for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                    reservedunmarshal_VkViewport(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                 (VkViewport*)(pViewports + i), readStreamPtrPtr);
+                }
+                if (pViewports) {
+                    for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                        transform_tohost_VkViewport(m_state, (VkViewport*)(pViewports + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetViewportWithCount 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)viewportCount, (unsigned long long)pViewports);
+                }
+                vk->vkCmdSetViewportWithCount(unboxed_commandBuffer, viewportCount, pViewports);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetViewportWithCount(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        viewportCount, pViewports);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetScissorWithCount: {
+                android::base::beginTrace("vkCmdSetScissorWithCount decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t scissorCount;
+                const VkRect2D* pScissors;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pScissors, ((scissorCount)) * sizeof(const VkRect2D));
+                for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+                    reservedunmarshal_VkRect2D(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                               (VkRect2D*)(pScissors + i), readStreamPtrPtr);
+                }
+                if (pScissors) {
+                    for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+                        transform_tohost_VkRect2D(m_state, (VkRect2D*)(pScissors + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetScissorWithCount 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)scissorCount, (unsigned long long)pScissors);
+                }
+                vk->vkCmdSetScissorWithCount(unboxed_commandBuffer, scissorCount, pScissors);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetScissorWithCount(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        scissorCount, pScissors);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBindVertexBuffers2: {
+                android::base::beginTrace("vkCmdBindVertexBuffers2 decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t firstBinding;
+                uint32_t bindingCount;
+                const VkBuffer* pBuffers;
+                const VkDeviceSize* pOffsets;
+                const VkDeviceSize* pSizes;
+                const VkDeviceSize* pStrides;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                // WARNING PTR CHECK
+                memcpy((VkBuffer**)&pBuffers, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pBuffers);
+                *readStreamPtrPtr += 8;
+                if (pBuffers) {
+                    vkReadStream->alloc((void**)&pBuffers,
+                                        ((bindingCount)) * sizeof(const VkBuffer));
+                    if (((bindingCount))) {
+                        uint8_t* cgen_var_1_0_ptr = (uint8_t*)(*readStreamPtrPtr);
+                        *readStreamPtrPtr += 8 * ((bindingCount));
+                        for (uint32_t k = 0; k < ((bindingCount)); ++k) {
+                            uint64_t tmpval;
+                            memcpy(&tmpval, cgen_var_1_0_ptr + k * 8, sizeof(uint64_t));
+                            *(((VkBuffer*)pBuffers) + k) =
+                                (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
+                        }
+                    }
+                }
+                vkReadStream->alloc((void**)&pOffsets,
+                                    ((bindingCount)) * sizeof(const VkDeviceSize));
+                memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
+                       ((bindingCount)) * sizeof(const VkDeviceSize));
+                *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
+                // WARNING PTR CHECK
+                memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pSizes);
+                *readStreamPtrPtr += 8;
+                if (pSizes) {
+                    vkReadStream->alloc((void**)&pSizes,
+                                        ((bindingCount)) * sizeof(const VkDeviceSize));
+                    memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
+                           ((bindingCount)) * sizeof(const VkDeviceSize));
+                    *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
+                }
+                // WARNING PTR CHECK
+                memcpy((VkDeviceSize**)&pStrides, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pStrides);
+                *readStreamPtrPtr += 8;
+                if (pStrides) {
+                    vkReadStream->alloc((void**)&pStrides,
+                                        ((bindingCount)) * sizeof(const VkDeviceSize));
+                    memcpy((VkDeviceSize*)pStrides, *readStreamPtrPtr,
+                           ((bindingCount)) * sizeof(const VkDeviceSize));
+                    *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdBindVertexBuffers2 0x%llx 0x%llx 0x%llx 0x%llx "
+                            "0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)firstBinding, (unsigned long long)bindingCount,
+                            (unsigned long long)pBuffers, (unsigned long long)pOffsets,
+                            (unsigned long long)pSizes, (unsigned long long)pStrides);
+                }
+                vk->vkCmdBindVertexBuffers2(unboxed_commandBuffer, firstBinding, bindingCount,
+                                            pBuffers, pOffsets, pSizes, pStrides);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdBindVertexBuffers2(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthTestEnable: {
+                android::base::beginTrace("vkCmdSetDepthTestEnable decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 depthTestEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&depthTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetDepthTestEnable 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)depthTestEnable);
+                }
+                vk->vkCmdSetDepthTestEnable(unboxed_commandBuffer, depthTestEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetDepthTestEnable(snapshotTraceBegin,
+                                                                 snapshotTraceBytes, &m_pool,
+                                                                 commandBuffer, depthTestEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthWriteEnable: {
+                android::base::beginTrace("vkCmdSetDepthWriteEnable decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 depthWriteEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&depthWriteEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetDepthWriteEnable 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)depthWriteEnable);
+                }
+                vk->vkCmdSetDepthWriteEnable(unboxed_commandBuffer, depthWriteEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetDepthWriteEnable(snapshotTraceBegin,
+                                                                  snapshotTraceBytes, &m_pool,
+                                                                  commandBuffer, depthWriteEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthCompareOp: {
+                android::base::beginTrace("vkCmdSetDepthCompareOp decode");
+                VkCommandBuffer commandBuffer;
+                VkCompareOp depthCompareOp;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkCompareOp*)&depthCompareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
+                *readStreamPtrPtr += sizeof(VkCompareOp);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetDepthCompareOp 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)depthCompareOp);
+                }
+                vk->vkCmdSetDepthCompareOp(unboxed_commandBuffer, depthCompareOp);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetDepthCompareOp(snapshotTraceBegin,
+                                                                snapshotTraceBytes, &m_pool,
+                                                                commandBuffer, depthCompareOp);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthBoundsTestEnable: {
+                android::base::beginTrace("vkCmdSetDepthBoundsTestEnable decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 depthBoundsTestEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&depthBoundsTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetDepthBoundsTestEnable 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)depthBoundsTestEnable);
+                }
+                vk->vkCmdSetDepthBoundsTestEnable(unboxed_commandBuffer, depthBoundsTestEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetDepthBoundsTestEnable(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        depthBoundsTestEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetStencilTestEnable: {
+                android::base::beginTrace("vkCmdSetStencilTestEnable decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 stencilTestEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&stencilTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetStencilTestEnable 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)stencilTestEnable);
+                }
+                vk->vkCmdSetStencilTestEnable(unboxed_commandBuffer, stencilTestEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetStencilTestEnable(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        stencilTestEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetStencilOp: {
+                android::base::beginTrace("vkCmdSetStencilOp decode");
+                VkCommandBuffer commandBuffer;
+                VkStencilFaceFlags faceMask;
+                VkStencilOp failOp;
+                VkStencilOp passOp;
+                VkStencilOp depthFailOp;
+                VkCompareOp compareOp;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
+                       sizeof(VkStencilFaceFlags));
+                *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
+                memcpy((VkStencilOp*)&failOp, *readStreamPtrPtr, sizeof(VkStencilOp));
+                *readStreamPtrPtr += sizeof(VkStencilOp);
+                memcpy((VkStencilOp*)&passOp, *readStreamPtrPtr, sizeof(VkStencilOp));
+                *readStreamPtrPtr += sizeof(VkStencilOp);
+                memcpy((VkStencilOp*)&depthFailOp, *readStreamPtrPtr, sizeof(VkStencilOp));
+                *readStreamPtrPtr += sizeof(VkStencilOp);
+                memcpy((VkCompareOp*)&compareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
+                *readStreamPtrPtr += sizeof(VkCompareOp);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetStencilOp 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)faceMask, (unsigned long long)failOp,
+                            (unsigned long long)passOp, (unsigned long long)depthFailOp,
+                            (unsigned long long)compareOp);
+                }
+                vk->vkCmdSetStencilOp(unboxed_commandBuffer, faceMask, failOp, passOp, depthFailOp,
+                                      compareOp);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetStencilOp(snapshotTraceBegin, snapshotTraceBytes,
+                                                           &m_pool, commandBuffer, faceMask, failOp,
+                                                           passOp, depthFailOp, compareOp);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetRasterizerDiscardEnable: {
+                android::base::beginTrace("vkCmdSetRasterizerDiscardEnable decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 rasterizerDiscardEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&rasterizerDiscardEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetRasterizerDiscardEnable 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)rasterizerDiscardEnable);
+                }
+                vk->vkCmdSetRasterizerDiscardEnable(unboxed_commandBuffer, rasterizerDiscardEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetRasterizerDiscardEnable(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        rasterizerDiscardEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthBiasEnable: {
+                android::base::beginTrace("vkCmdSetDepthBiasEnable decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 depthBiasEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&depthBiasEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetDepthBiasEnable 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)depthBiasEnable);
+                }
+                vk->vkCmdSetDepthBiasEnable(unboxed_commandBuffer, depthBiasEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetDepthBiasEnable(snapshotTraceBegin,
+                                                                 snapshotTraceBytes, &m_pool,
+                                                                 commandBuffer, depthBiasEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetPrimitiveRestartEnable: {
+                android::base::beginTrace("vkCmdSetPrimitiveRestartEnable decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 primitiveRestartEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&primitiveRestartEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetPrimitiveRestartEnable 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)primitiveRestartEnable);
+                }
+                vk->vkCmdSetPrimitiveRestartEnable(unboxed_commandBuffer, primitiveRestartEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetPrimitiveRestartEnable(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        primitiveRestartEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetDeviceBufferMemoryRequirements: {
+                android::base::beginTrace("vkGetDeviceBufferMemoryRequirements decode");
+                VkDevice device;
+                const VkDeviceBufferMemoryRequirements* pInfo;
+                VkMemoryRequirements2* pMemoryRequirements;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceBufferMemoryRequirements));
+                reservedunmarshal_VkDeviceBufferMemoryRequirements(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkDeviceBufferMemoryRequirements*)(pInfo), readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pMemoryRequirements;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements2));
+                reservedunmarshal_VkMemoryRequirements2(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkMemoryRequirements2*)(pMemoryRequirements), readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkDeviceBufferMemoryRequirements(
+                        m_state, (VkDeviceBufferMemoryRequirements*)(pInfo));
+                }
+                if (pMemoryRequirements) {
+                    transform_tohost_VkMemoryRequirements2(
+                        m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetDeviceBufferMemoryRequirements 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pInfo,
+                            (unsigned long long)pMemoryRequirements);
+                }
+                vk->vkGetDeviceBufferMemoryRequirements(unboxed_device, pInfo, pMemoryRequirements);
+                vkStream->unsetHandleMapping();
+                if (pMemoryRequirements) {
+                    transform_fromhost_VkMemoryRequirements2(
+                        m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
+                }
+                marshal_VkMemoryRequirements2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                              (VkMemoryRequirements2*)(pMemoryRequirements));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetDeviceBufferMemoryRequirements(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
+                        pMemoryRequirements);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetDeviceImageMemoryRequirements: {
+                android::base::beginTrace("vkGetDeviceImageMemoryRequirements decode");
+                VkDevice device;
+                const VkDeviceImageMemoryRequirements* pInfo;
+                VkMemoryRequirements2* pMemoryRequirements;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceImageMemoryRequirements));
+                reservedunmarshal_VkDeviceImageMemoryRequirements(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkDeviceImageMemoryRequirements*)(pInfo), readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pMemoryRequirements;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements2));
+                reservedunmarshal_VkMemoryRequirements2(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkMemoryRequirements2*)(pMemoryRequirements), readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkDeviceImageMemoryRequirements(
+                        m_state, (VkDeviceImageMemoryRequirements*)(pInfo));
+                }
+                if (pMemoryRequirements) {
+                    transform_tohost_VkMemoryRequirements2(
+                        m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetDeviceImageMemoryRequirements 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pInfo,
+                            (unsigned long long)pMemoryRequirements);
+                }
+                vk->vkGetDeviceImageMemoryRequirements(unboxed_device, pInfo, pMemoryRequirements);
+                vkStream->unsetHandleMapping();
+                if (pMemoryRequirements) {
+                    transform_fromhost_VkMemoryRequirements2(
+                        m_state, (VkMemoryRequirements2*)(pMemoryRequirements));
+                }
+                marshal_VkMemoryRequirements2(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                              (VkMemoryRequirements2*)(pMemoryRequirements));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetDeviceImageMemoryRequirements(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
+                        pMemoryRequirements);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetDeviceImageSparseMemoryRequirements: {
+                android::base::beginTrace("vkGetDeviceImageSparseMemoryRequirements decode");
+                VkDevice device;
+                const VkDeviceImageMemoryRequirements* pInfo;
+                uint32_t* pSparseMemoryRequirementCount;
+                VkSparseImageMemoryRequirements2* pSparseMemoryRequirements;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceImageMemoryRequirements));
+                reservedunmarshal_VkDeviceImageMemoryRequirements(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkDeviceImageMemoryRequirements*)(pInfo), readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pSparseMemoryRequirementCount;
+                vkReadStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                memcpy((uint32_t**)&pSparseMemoryRequirementCount, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pSparseMemoryRequirementCount);
+                *readStreamPtrPtr += 8;
+                if (pSparseMemoryRequirementCount) {
+                    vkReadStream->alloc((void**)&pSparseMemoryRequirementCount, sizeof(uint32_t));
+                    memcpy((uint32_t*)pSparseMemoryRequirementCount, *readStreamPtrPtr,
+                           sizeof(uint32_t));
+                    *readStreamPtrPtr += sizeof(uint32_t);
+                }
+                // Begin manual dispatchable handle unboxing for pSparseMemoryRequirements;
+                vkReadStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                memcpy((VkSparseImageMemoryRequirements2**)&pSparseMemoryRequirements,
+                       (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pSparseMemoryRequirements);
+                *readStreamPtrPtr += 8;
+                if (pSparseMemoryRequirements) {
+                    vkReadStream->alloc((void**)&pSparseMemoryRequirements,
+                                        (*(pSparseMemoryRequirementCount)) *
+                                            sizeof(VkSparseImageMemoryRequirements2));
+                    for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount)); ++i) {
+                        reservedunmarshal_VkSparseImageMemoryRequirements2(
+                            vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                            (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i),
+                            readStreamPtrPtr);
+                    }
+                }
+                if (pInfo) {
+                    transform_tohost_VkDeviceImageMemoryRequirements(
+                        m_state, (VkDeviceImageMemoryRequirements*)(pInfo));
+                }
+                if (pSparseMemoryRequirementCount) {
+                    if (pSparseMemoryRequirements) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
+                             ++i) {
+                            transform_tohost_VkSparseImageMemoryRequirements2(
+                                m_state,
+                                (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+                        }
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetDeviceImageSparseMemoryRequirements 0x%llx "
+                            "0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pInfo,
+                            (unsigned long long)pSparseMemoryRequirementCount,
+                            (unsigned long long)pSparseMemoryRequirements);
+                }
+                vk->vkGetDeviceImageSparseMemoryRequirements(unboxed_device, pInfo,
+                                                             pSparseMemoryRequirementCount,
+                                                             pSparseMemoryRequirements);
+                vkStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pSparseMemoryRequirementCount;
+                vkStream->putBe64(cgen_var_3);
+                if (pSparseMemoryRequirementCount) {
+                    vkStream->write((uint32_t*)pSparseMemoryRequirementCount, sizeof(uint32_t));
+                }
+                if (pSparseMemoryRequirementCount) {
+                    if (pSparseMemoryRequirements) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
+                             ++i) {
+                            transform_fromhost_VkSparseImageMemoryRequirements2(
+                                m_state,
+                                (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+                        }
+                    }
+                }
+                // WARNING PTR CHECK
+                uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pSparseMemoryRequirements;
+                vkStream->putBe64(cgen_var_4);
+                if (pSparseMemoryRequirements) {
+                    if (pSparseMemoryRequirementCount) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pSparseMemoryRequirementCount));
+                             ++i) {
+                            marshal_VkSparseImageMemoryRequirements2(
+                                vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                (VkSparseImageMemoryRequirements2*)(pSparseMemoryRequirements + i));
+                        }
+                    }
+                }
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetDeviceImageSparseMemoryRequirements(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pInfo,
+                        pSparseMemoryRequirementCount, pSparseMemoryRequirements);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
 #ifdef VK_KHR_surface
             case OP_vkDestroySurfaceKHR: {
                 android::base::beginTrace("vkDestroySurfaceKHR decode");
@@ -13659,7 +15507,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkGetPhysicalDeviceVideoCapabilitiesKHR: {
                 android::base::beginTrace("vkGetPhysicalDeviceVideoCapabilitiesKHR decode");
                 VkPhysicalDevice physicalDevice;
-                const VkVideoProfileKHR* pVideoProfile;
+                const VkVideoProfileInfoKHR* pVideoProfile;
                 VkVideoCapabilitiesKHR* pCapabilities;
                 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
                 uint64_t cgen_var_0;
@@ -13670,10 +15518,10 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
                 auto vk = dispatch_VkPhysicalDevice(physicalDevice);
                 // End manual dispatchable handle unboxing for physicalDevice;
-                vkReadStream->alloc((void**)&pVideoProfile, sizeof(const VkVideoProfileKHR));
-                reservedunmarshal_VkVideoProfileKHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                    (VkVideoProfileKHR*)(pVideoProfile),
-                                                    readStreamPtrPtr);
+                vkReadStream->alloc((void**)&pVideoProfile, sizeof(const VkVideoProfileInfoKHR));
+                reservedunmarshal_VkVideoProfileInfoKHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                        (VkVideoProfileInfoKHR*)(pVideoProfile),
+                                                        readStreamPtrPtr);
                 // Begin manual dispatchable handle unboxing for pCapabilities;
                 vkReadStream->unsetHandleMapping();
                 vkReadStream->alloc((void**)&pCapabilities, sizeof(VkVideoCapabilitiesKHR));
@@ -13681,8 +15529,8 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                                                          (VkVideoCapabilitiesKHR*)(pCapabilities),
                                                          readStreamPtrPtr);
                 if (pVideoProfile) {
-                    transform_tohost_VkVideoProfileKHR(m_state,
-                                                       (VkVideoProfileKHR*)(pVideoProfile));
+                    transform_tohost_VkVideoProfileInfoKHR(m_state,
+                                                           (VkVideoProfileInfoKHR*)(pVideoProfile));
                 }
                 if (pCapabilities) {
                     transform_tohost_VkVideoCapabilitiesKHR(
@@ -13988,8 +15836,8 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 android::base::beginTrace("vkGetVideoSessionMemoryRequirementsKHR decode");
                 VkDevice device;
                 VkVideoSessionKHR videoSession;
-                uint32_t* pVideoSessionMemoryRequirementsCount;
-                VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements;
+                uint32_t* pMemoryRequirementsCount;
+                VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements;
                 // Begin non wrapped dispatchable handle unboxing for device;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -14001,47 +15849,42 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 memcpy((VkVideoSessionKHR*)&videoSession, (*readStreamPtrPtr), 8);
                 android::base::Stream::fromBe64((uint8_t*)&videoSession);
                 *readStreamPtrPtr += 8;
-                // Begin manual dispatchable handle unboxing for
-                // pVideoSessionMemoryRequirementsCount;
+                // Begin manual dispatchable handle unboxing for pMemoryRequirementsCount;
                 vkReadStream->unsetHandleMapping();
                 // WARNING PTR CHECK
-                memcpy((uint32_t**)&pVideoSessionMemoryRequirementsCount, (*readStreamPtrPtr), 8);
-                android::base::Stream::fromBe64((uint8_t*)&pVideoSessionMemoryRequirementsCount);
+                memcpy((uint32_t**)&pMemoryRequirementsCount, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pMemoryRequirementsCount);
                 *readStreamPtrPtr += 8;
-                if (pVideoSessionMemoryRequirementsCount) {
-                    vkReadStream->alloc((void**)&pVideoSessionMemoryRequirementsCount,
-                                        sizeof(uint32_t));
-                    memcpy((uint32_t*)pVideoSessionMemoryRequirementsCount, *readStreamPtrPtr,
+                if (pMemoryRequirementsCount) {
+                    vkReadStream->alloc((void**)&pMemoryRequirementsCount, sizeof(uint32_t));
+                    memcpy((uint32_t*)pMemoryRequirementsCount, *readStreamPtrPtr,
                            sizeof(uint32_t));
                     *readStreamPtrPtr += sizeof(uint32_t);
                 }
-                // Begin manual dispatchable handle unboxing for pVideoSessionMemoryRequirements;
+                // Begin manual dispatchable handle unboxing for pMemoryRequirements;
                 vkReadStream->unsetHandleMapping();
                 // WARNING PTR CHECK
-                memcpy((VkVideoGetMemoryPropertiesKHR**)&pVideoSessionMemoryRequirements,
+                memcpy((VkVideoSessionMemoryRequirementsKHR**)&pMemoryRequirements,
                        (*readStreamPtrPtr), 8);
-                android::base::Stream::fromBe64((uint8_t*)&pVideoSessionMemoryRequirements);
-                *readStreamPtrPtr += 8;
-                if (pVideoSessionMemoryRequirements) {
-                    vkReadStream->alloc((void**)&pVideoSessionMemoryRequirements,
-                                        (*(pVideoSessionMemoryRequirementsCount)) *
-                                            sizeof(VkVideoGetMemoryPropertiesKHR));
-                    for (uint32_t i = 0; i < (uint32_t)(*(pVideoSessionMemoryRequirementsCount));
-                         ++i) {
-                        reservedunmarshal_VkVideoGetMemoryPropertiesKHR(
+                android::base::Stream::fromBe64((uint8_t*)&pMemoryRequirements);
+                *readStreamPtrPtr += 8;
+                if (pMemoryRequirements) {
+                    vkReadStream->alloc((void**)&pMemoryRequirements,
+                                        (*(pMemoryRequirementsCount)) *
+                                            sizeof(VkVideoSessionMemoryRequirementsKHR));
+                    for (uint32_t i = 0; i < (uint32_t)(*(pMemoryRequirementsCount)); ++i) {
+                        reservedunmarshal_VkVideoSessionMemoryRequirementsKHR(
                             vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                            (VkVideoGetMemoryPropertiesKHR*)(pVideoSessionMemoryRequirements + i),
+                            (VkVideoSessionMemoryRequirementsKHR*)(pMemoryRequirements + i),
                             readStreamPtrPtr);
                     }
                 }
-                if (pVideoSessionMemoryRequirementsCount) {
-                    if (pVideoSessionMemoryRequirements) {
-                        for (uint32_t i = 0;
-                             i < (uint32_t)(*(pVideoSessionMemoryRequirementsCount)); ++i) {
-                            transform_tohost_VkVideoGetMemoryPropertiesKHR(
+                if (pMemoryRequirementsCount) {
+                    if (pMemoryRequirements) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pMemoryRequirementsCount)); ++i) {
+                            transform_tohost_VkVideoSessionMemoryRequirementsKHR(
                                 m_state,
-                                (VkVideoGetMemoryPropertiesKHR*)(pVideoSessionMemoryRequirements +
-                                                                 i));
+                                (VkVideoSessionMemoryRequirementsKHR*)(pMemoryRequirements + i));
                         }
                     }
                 }
@@ -14050,14 +15893,14 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                             "stream %p: call vkGetVideoSessionMemoryRequirementsKHR 0x%llx 0x%llx "
                             "0x%llx 0x%llx \n",
                             ioStream, (unsigned long long)device, (unsigned long long)videoSession,
-                            (unsigned long long)pVideoSessionMemoryRequirementsCount,
-                            (unsigned long long)pVideoSessionMemoryRequirements);
+                            (unsigned long long)pMemoryRequirementsCount,
+                            (unsigned long long)pMemoryRequirements);
                 }
                 VkResult vkGetVideoSessionMemoryRequirementsKHR_VkResult_return = (VkResult)0;
                 vkGetVideoSessionMemoryRequirementsKHR_VkResult_return =
                     vk->vkGetVideoSessionMemoryRequirementsKHR(unboxed_device, videoSession,
-                                                               pVideoSessionMemoryRequirementsCount,
-                                                               pVideoSessionMemoryRequirements);
+                                                               pMemoryRequirementsCount,
+                                                               pMemoryRequirements);
                 if ((vkGetVideoSessionMemoryRequirementsKHR_VkResult_return) ==
                     VK_ERROR_DEVICE_LOST)
                     m_state->on_DeviceLost();
@@ -14065,34 +15908,29 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                                              opcode, context);
                 vkStream->unsetHandleMapping();
                 // WARNING PTR CHECK
-                uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pVideoSessionMemoryRequirementsCount;
+                uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pMemoryRequirementsCount;
                 vkStream->putBe64(cgen_var_4);
-                if (pVideoSessionMemoryRequirementsCount) {
-                    vkStream->write((uint32_t*)pVideoSessionMemoryRequirementsCount,
-                                    sizeof(uint32_t));
-                }
-                if (pVideoSessionMemoryRequirementsCount) {
-                    if (pVideoSessionMemoryRequirements) {
-                        for (uint32_t i = 0;
-                             i < (uint32_t)(*(pVideoSessionMemoryRequirementsCount)); ++i) {
-                            transform_fromhost_VkVideoGetMemoryPropertiesKHR(
+                if (pMemoryRequirementsCount) {
+                    vkStream->write((uint32_t*)pMemoryRequirementsCount, sizeof(uint32_t));
+                }
+                if (pMemoryRequirementsCount) {
+                    if (pMemoryRequirements) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pMemoryRequirementsCount)); ++i) {
+                            transform_fromhost_VkVideoSessionMemoryRequirementsKHR(
                                 m_state,
-                                (VkVideoGetMemoryPropertiesKHR*)(pVideoSessionMemoryRequirements +
-                                                                 i));
+                                (VkVideoSessionMemoryRequirementsKHR*)(pMemoryRequirements + i));
                         }
                     }
                 }
                 // WARNING PTR CHECK
-                uint64_t cgen_var_5 = (uint64_t)(uintptr_t)pVideoSessionMemoryRequirements;
+                uint64_t cgen_var_5 = (uint64_t)(uintptr_t)pMemoryRequirements;
                 vkStream->putBe64(cgen_var_5);
-                if (pVideoSessionMemoryRequirements) {
-                    if (pVideoSessionMemoryRequirementsCount) {
-                        for (uint32_t i = 0;
-                             i < (uint32_t)(*(pVideoSessionMemoryRequirementsCount)); ++i) {
-                            marshal_VkVideoGetMemoryPropertiesKHR(
+                if (pMemoryRequirements) {
+                    if (pMemoryRequirementsCount) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pMemoryRequirementsCount)); ++i) {
+                            marshal_VkVideoSessionMemoryRequirementsKHR(
                                 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                (VkVideoGetMemoryPropertiesKHR*)(pVideoSessionMemoryRequirements +
-                                                                 i));
+                                (VkVideoSessionMemoryRequirementsKHR*)(pMemoryRequirements + i));
                         }
                     }
                 }
@@ -14106,8 +15944,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                     m_state->snapshot()->vkGetVideoSessionMemoryRequirementsKHR(
                         snapshotTraceBegin, snapshotTraceBytes, &m_pool,
                         vkGetVideoSessionMemoryRequirementsKHR_VkResult_return, device,
-                        videoSession, pVideoSessionMemoryRequirementsCount,
-                        pVideoSessionMemoryRequirements);
+                        videoSession, pMemoryRequirementsCount, pMemoryRequirements);
                 }
                 vkReadStream->clearPool();
                 if (queueSubmitWithCommandsEnabled)
@@ -14119,8 +15956,8 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 android::base::beginTrace("vkBindVideoSessionMemoryKHR decode");
                 VkDevice device;
                 VkVideoSessionKHR videoSession;
-                uint32_t videoSessionBindMemoryCount;
-                const VkVideoBindMemoryKHR* pVideoSessionBindMemories;
+                uint32_t bindSessionMemoryInfoCount;
+                const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos;
                 // Begin non wrapped dispatchable handle unboxing for device;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -14132,21 +15969,22 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 memcpy((VkVideoSessionKHR*)&videoSession, (*readStreamPtrPtr), 8);
                 android::base::Stream::fromBe64((uint8_t*)&videoSession);
                 *readStreamPtrPtr += 8;
-                memcpy((uint32_t*)&videoSessionBindMemoryCount, *readStreamPtrPtr,
-                       sizeof(uint32_t));
+                memcpy((uint32_t*)&bindSessionMemoryInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
                 *readStreamPtrPtr += sizeof(uint32_t);
                 vkReadStream->alloc(
-                    (void**)&pVideoSessionBindMemories,
-                    ((videoSessionBindMemoryCount)) * sizeof(const VkVideoBindMemoryKHR));
-                for (uint32_t i = 0; i < (uint32_t)((videoSessionBindMemoryCount)); ++i) {
-                    reservedunmarshal_VkVideoBindMemoryKHR(
+                    (void**)&pBindSessionMemoryInfos,
+                    ((bindSessionMemoryInfoCount)) * sizeof(const VkBindVideoSessionMemoryInfoKHR));
+                for (uint32_t i = 0; i < (uint32_t)((bindSessionMemoryInfoCount)); ++i) {
+                    reservedunmarshal_VkBindVideoSessionMemoryInfoKHR(
                         vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                        (VkVideoBindMemoryKHR*)(pVideoSessionBindMemories + i), readStreamPtrPtr);
+                        (VkBindVideoSessionMemoryInfoKHR*)(pBindSessionMemoryInfos + i),
+                        readStreamPtrPtr);
                 }
-                if (pVideoSessionBindMemories) {
-                    for (uint32_t i = 0; i < (uint32_t)((videoSessionBindMemoryCount)); ++i) {
-                        transform_tohost_VkVideoBindMemoryKHR(
-                            m_state, (VkVideoBindMemoryKHR*)(pVideoSessionBindMemories + i));
+                if (pBindSessionMemoryInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((bindSessionMemoryInfoCount)); ++i) {
+                        transform_tohost_VkBindVideoSessionMemoryInfoKHR(
+                            m_state,
+                            (VkBindVideoSessionMemoryInfoKHR*)(pBindSessionMemoryInfos + i));
                     }
                 }
                 if (m_logCalls) {
@@ -14154,13 +15992,13 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                             "stream %p: call vkBindVideoSessionMemoryKHR 0x%llx 0x%llx 0x%llx "
                             "0x%llx \n",
                             ioStream, (unsigned long long)device, (unsigned long long)videoSession,
-                            (unsigned long long)videoSessionBindMemoryCount,
-                            (unsigned long long)pVideoSessionBindMemories);
+                            (unsigned long long)bindSessionMemoryInfoCount,
+                            (unsigned long long)pBindSessionMemoryInfos);
                 }
                 VkResult vkBindVideoSessionMemoryKHR_VkResult_return = (VkResult)0;
                 vkBindVideoSessionMemoryKHR_VkResult_return = vk->vkBindVideoSessionMemoryKHR(
-                    unboxed_device, videoSession, videoSessionBindMemoryCount,
-                    pVideoSessionBindMemories);
+                    unboxed_device, videoSession, bindSessionMemoryInfoCount,
+                    pBindSessionMemoryInfos);
                 if ((vkBindVideoSessionMemoryKHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
                     m_state->on_DeviceLost();
                 m_state->on_CheckOutOfMemory(vkBindVideoSessionMemoryKHR_VkResult_return, opcode,
@@ -14175,7 +16013,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                     m_state->snapshot()->vkBindVideoSessionMemoryKHR(
                         snapshotTraceBegin, snapshotTraceBytes, &m_pool,
                         vkBindVideoSessionMemoryKHR_VkResult_return, device, videoSession,
-                        videoSessionBindMemoryCount, pVideoSessionBindMemories);
+                        bindSessionMemoryInfoCount, pBindSessionMemoryInfos);
                 }
                 vkReadStream->clearPool();
                 if (queueSubmitWithCommandsEnabled)
@@ -14513,7 +16351,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkCmdDecodeVideoKHR: {
                 android::base::beginTrace("vkCmdDecodeVideoKHR decode");
                 VkCommandBuffer commandBuffer;
-                const VkVideoDecodeInfoKHR* pFrameInfo;
+                const VkVideoDecodeInfoKHR* pDecodeInfo;
                 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -14523,27 +16361,27 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
                 auto vk = dispatch_VkCommandBuffer(commandBuffer);
                 // End manual dispatchable handle unboxing for commandBuffer;
-                vkReadStream->alloc((void**)&pFrameInfo, sizeof(const VkVideoDecodeInfoKHR));
+                vkReadStream->alloc((void**)&pDecodeInfo, sizeof(const VkVideoDecodeInfoKHR));
                 reservedunmarshal_VkVideoDecodeInfoKHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                       (VkVideoDecodeInfoKHR*)(pFrameInfo),
+                                                       (VkVideoDecodeInfoKHR*)(pDecodeInfo),
                                                        readStreamPtrPtr);
-                if (pFrameInfo) {
+                if (pDecodeInfo) {
                     transform_tohost_VkVideoDecodeInfoKHR(m_state,
-                                                          (VkVideoDecodeInfoKHR*)(pFrameInfo));
+                                                          (VkVideoDecodeInfoKHR*)(pDecodeInfo));
                 }
                 if (m_logCalls) {
                     fprintf(stderr, "stream %p: call vkCmdDecodeVideoKHR 0x%llx 0x%llx \n",
                             ioStream, (unsigned long long)commandBuffer,
-                            (unsigned long long)pFrameInfo);
+                            (unsigned long long)pDecodeInfo);
                 }
-                vk->vkCmdDecodeVideoKHR(unboxed_commandBuffer, pFrameInfo);
+                vk->vkCmdDecodeVideoKHR(unboxed_commandBuffer, pDecodeInfo);
                 vkStream->unsetHandleMapping();
                 vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
                                          (uintptr_t)snapshotTraceBegin);
                 size_t snapshotTraceBytes = vkReadStream->endTrace();
                 if (m_state->snapshotsEnabled()) {
                     m_state->snapshot()->vkCmdDecodeVideoKHR(snapshotTraceBegin, snapshotTraceBytes,
-                                                             &m_pool, commandBuffer, pFrameInfo);
+                                                             &m_pool, commandBuffer, pDecodeInfo);
                 }
                 vkReadStream->clearPool();
                 if (queueSubmitWithCommandsEnabled)
@@ -14552,11 +16390,13 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 break;
             }
 #endif
+#ifdef VK_KHR_video_decode_h264
+#endif
 #ifdef VK_KHR_dynamic_rendering
             case OP_vkCmdBeginRenderingKHR: {
                 android::base::beginTrace("vkCmdBeginRenderingKHR decode");
                 VkCommandBuffer commandBuffer;
-                const VkRenderingInfoKHR* pRenderingInfo;
+                const VkRenderingInfo* pRenderingInfo;
                 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -14566,13 +16406,12 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
                 auto vk = dispatch_VkCommandBuffer(commandBuffer);
                 // End manual dispatchable handle unboxing for commandBuffer;
-                vkReadStream->alloc((void**)&pRenderingInfo, sizeof(const VkRenderingInfoKHR));
-                reservedunmarshal_VkRenderingInfoKHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                     (VkRenderingInfoKHR*)(pRenderingInfo),
-                                                     readStreamPtrPtr);
+                vkReadStream->alloc((void**)&pRenderingInfo, sizeof(const VkRenderingInfo));
+                reservedunmarshal_VkRenderingInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                  (VkRenderingInfo*)(pRenderingInfo),
+                                                  readStreamPtrPtr);
                 if (pRenderingInfo) {
-                    transform_tohost_VkRenderingInfoKHR(m_state,
-                                                        (VkRenderingInfoKHR*)(pRenderingInfo));
+                    transform_tohost_VkRenderingInfo(m_state, (VkRenderingInfo*)(pRenderingInfo));
                 }
                 if (m_logCalls) {
                     fprintf(stderr, "stream %p: call vkCmdBeginRenderingKHR 0x%llx 0x%llx \n",
@@ -18613,6 +20452,10 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
 #endif
 #ifdef VK_KHR_shader_clock
 #endif
+#ifdef VK_KHR_video_decode_h265
+#endif
+#ifdef VK_KHR_global_priority
+#endif
 #ifdef VK_KHR_driver_properties
 #endif
 #ifdef VK_KHR_shader_float_controls
@@ -19773,6 +21616,121 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 break;
             }
 #endif
+#ifdef VK_KHR_map_memory2
+            case OP_vkMapMemory2KHR: {
+                android::base::beginTrace("vkMapMemory2KHR decode");
+                VkDevice device;
+                const VkMemoryMapInfoKHR* pMemoryMapInfo;
+                void** ppData;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pMemoryMapInfo, sizeof(const VkMemoryMapInfoKHR));
+                reservedunmarshal_VkMemoryMapInfoKHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                     (VkMemoryMapInfoKHR*)(pMemoryMapInfo),
+                                                     readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for ppData;
+                vkReadStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                memcpy((void***)&ppData, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&ppData);
+                *readStreamPtrPtr += 8;
+                if (ppData) {
+                    vkReadStream->alloc((void**)&ppData, sizeof(void*));
+                    memcpy((void**)ppData, *readStreamPtrPtr, sizeof(void*));
+                    *readStreamPtrPtr += sizeof(void*);
+                }
+                if (pMemoryMapInfo) {
+                    transform_tohost_VkMemoryMapInfoKHR(m_state,
+                                                        (VkMemoryMapInfoKHR*)(pMemoryMapInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkMapMemory2KHR 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device,
+                            (unsigned long long)pMemoryMapInfo, (unsigned long long)ppData);
+                }
+                VkResult vkMapMemory2KHR_VkResult_return = (VkResult)0;
+                vkMapMemory2KHR_VkResult_return =
+                    vk->vkMapMemory2KHR(unboxed_device, pMemoryMapInfo, ppData);
+                if ((vkMapMemory2KHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkMapMemory2KHR_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                uint64_t cgen_var_2 = (uint64_t)(uintptr_t)ppData;
+                vkStream->putBe64(cgen_var_2);
+                if (ppData) {
+                    vkStream->write((void**)ppData, sizeof(void*));
+                }
+                vkStream->write(&vkMapMemory2KHR_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkMapMemory2KHR(snapshotTraceBegin, snapshotTraceBytes,
+                                                         &m_pool, vkMapMemory2KHR_VkResult_return,
+                                                         device, pMemoryMapInfo, ppData);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkUnmapMemory2KHR: {
+                android::base::beginTrace("vkUnmapMemory2KHR decode");
+                VkDevice device;
+                const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pMemoryUnmapInfo, sizeof(const VkMemoryUnmapInfoKHR));
+                reservedunmarshal_VkMemoryUnmapInfoKHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                       (VkMemoryUnmapInfoKHR*)(pMemoryUnmapInfo),
+                                                       readStreamPtrPtr);
+                if (pMemoryUnmapInfo) {
+                    transform_tohost_VkMemoryUnmapInfoKHR(
+                        m_state, (VkMemoryUnmapInfoKHR*)(pMemoryUnmapInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkUnmapMemory2KHR 0x%llx 0x%llx \n", ioStream,
+                            (unsigned long long)device, (unsigned long long)pMemoryUnmapInfo);
+                }
+                VkResult vkUnmapMemory2KHR_VkResult_return = (VkResult)0;
+                vkUnmapMemory2KHR_VkResult_return =
+                    vk->vkUnmapMemory2KHR(unboxed_device, pMemoryUnmapInfo);
+                if ((vkUnmapMemory2KHR_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkUnmapMemory2KHR_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                vkStream->write(&vkUnmapMemory2KHR_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkUnmapMemory2KHR(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkUnmapMemory2KHR_VkResult_return, device, pMemoryUnmapInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -19829,7 +21787,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 android::base::beginTrace("vkCmdSetEvent2KHR decode");
                 VkCommandBuffer commandBuffer;
                 VkEvent event;
-                const VkDependencyInfoKHR* pDependencyInfo;
+                const VkDependencyInfo* pDependencyInfo;
                 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -19843,13 +21801,13 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
                 *readStreamPtrPtr += 1 * 8;
                 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
-                vkReadStream->alloc((void**)&pDependencyInfo, sizeof(const VkDependencyInfoKHR));
-                reservedunmarshal_VkDependencyInfoKHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                      (VkDependencyInfoKHR*)(pDependencyInfo),
-                                                      readStreamPtrPtr);
+                vkReadStream->alloc((void**)&pDependencyInfo, sizeof(const VkDependencyInfo));
+                reservedunmarshal_VkDependencyInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkDependencyInfo*)(pDependencyInfo),
+                                                   readStreamPtrPtr);
                 if (pDependencyInfo) {
-                    transform_tohost_VkDependencyInfoKHR(m_state,
-                                                         (VkDependencyInfoKHR*)(pDependencyInfo));
+                    transform_tohost_VkDependencyInfo(m_state,
+                                                      (VkDependencyInfo*)(pDependencyInfo));
                 }
                 if (m_logCalls) {
                     fprintf(stderr, "stream %p: call vkCmdSetEvent2KHR 0x%llx 0x%llx 0x%llx \n",
@@ -19876,7 +21834,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 android::base::beginTrace("vkCmdResetEvent2KHR decode");
                 VkCommandBuffer commandBuffer;
                 VkEvent event;
-                VkPipelineStageFlags2KHR stageMask;
+                VkPipelineStageFlags2 stageMask;
                 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -19890,9 +21848,9 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
                 *readStreamPtrPtr += 1 * 8;
                 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
-                memcpy((VkPipelineStageFlags2KHR*)&stageMask, *readStreamPtrPtr,
-                       sizeof(VkPipelineStageFlags2KHR));
-                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2KHR);
+                memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlags2));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
                 if (m_logCalls) {
                     fprintf(stderr, "stream %p: call vkCmdResetEvent2KHR 0x%llx 0x%llx 0x%llx \n",
                             ioStream, (unsigned long long)commandBuffer, (unsigned long long)event,
@@ -19919,7 +21877,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 VkCommandBuffer commandBuffer;
                 uint32_t eventCount;
                 const VkEvent* pEvents;
-                const VkDependencyInfoKHR* pDependencyInfos;
+                const VkDependencyInfo* pDependencyInfos;
                 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -19942,16 +21900,16 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                     }
                 }
                 vkReadStream->alloc((void**)&pDependencyInfos,
-                                    ((eventCount)) * sizeof(const VkDependencyInfoKHR));
+                                    ((eventCount)) * sizeof(const VkDependencyInfo));
                 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
-                    reservedunmarshal_VkDependencyInfoKHR(
-                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                        (VkDependencyInfoKHR*)(pDependencyInfos + i), readStreamPtrPtr);
+                    reservedunmarshal_VkDependencyInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                       (VkDependencyInfo*)(pDependencyInfos + i),
+                                                       readStreamPtrPtr);
                 }
                 if (pDependencyInfos) {
                     for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
-                        transform_tohost_VkDependencyInfoKHR(
-                            m_state, (VkDependencyInfoKHR*)(pDependencyInfos + i));
+                        transform_tohost_VkDependencyInfo(
+                            m_state, (VkDependencyInfo*)(pDependencyInfos + i));
                     }
                 }
                 if (m_logCalls) {
@@ -19981,7 +21939,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkCmdPipelineBarrier2KHR: {
                 android::base::beginTrace("vkCmdPipelineBarrier2KHR decode");
                 VkCommandBuffer commandBuffer;
-                const VkDependencyInfoKHR* pDependencyInfo;
+                const VkDependencyInfo* pDependencyInfo;
                 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -19991,13 +21949,13 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
                 auto vk = dispatch_VkCommandBuffer(commandBuffer);
                 // End manual dispatchable handle unboxing for commandBuffer;
-                vkReadStream->alloc((void**)&pDependencyInfo, sizeof(const VkDependencyInfoKHR));
-                reservedunmarshal_VkDependencyInfoKHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                      (VkDependencyInfoKHR*)(pDependencyInfo),
-                                                      readStreamPtrPtr);
+                vkReadStream->alloc((void**)&pDependencyInfo, sizeof(const VkDependencyInfo));
+                reservedunmarshal_VkDependencyInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkDependencyInfo*)(pDependencyInfo),
+                                                   readStreamPtrPtr);
                 if (pDependencyInfo) {
-                    transform_tohost_VkDependencyInfoKHR(m_state,
-                                                         (VkDependencyInfoKHR*)(pDependencyInfo));
+                    transform_tohost_VkDependencyInfo(m_state,
+                                                      (VkDependencyInfo*)(pDependencyInfo));
                 }
                 if (m_logCalls) {
                     fprintf(stderr, "stream %p: call vkCmdPipelineBarrier2KHR 0x%llx 0x%llx \n",
@@ -20023,7 +21981,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkCmdWriteTimestamp2KHR: {
                 android::base::beginTrace("vkCmdWriteTimestamp2KHR decode");
                 VkCommandBuffer commandBuffer;
-                VkPipelineStageFlags2KHR stage;
+                VkPipelineStageFlags2 stage;
                 VkQueryPool queryPool;
                 uint32_t query;
                 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
@@ -20035,9 +21993,9 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
                 auto vk = dispatch_VkCommandBuffer(commandBuffer);
                 // End manual dispatchable handle unboxing for commandBuffer;
-                memcpy((VkPipelineStageFlags2KHR*)&stage, *readStreamPtrPtr,
-                       sizeof(VkPipelineStageFlags2KHR));
-                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2KHR);
+                memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlags2));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
                 uint64_t cgen_var_1;
                 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
                 *readStreamPtrPtr += 1 * 8;
@@ -20072,7 +22030,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 android::base::beginTrace("vkQueueSubmit2KHR decode");
                 VkQueue queue;
                 uint32_t submitCount;
-                const VkSubmitInfo2KHR* pSubmits;
+                const VkSubmitInfo2* pSubmits;
                 VkFence fence;
                 // Begin non wrapped dispatchable handle unboxing for queue;
                 uint64_t cgen_var_0;
@@ -20085,11 +22043,11 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 memcpy((uint32_t*)&submitCount, *readStreamPtrPtr, sizeof(uint32_t));
                 *readStreamPtrPtr += sizeof(uint32_t);
                 vkReadStream->alloc((void**)&pSubmits,
-                                    ((submitCount)) * sizeof(const VkSubmitInfo2KHR));
+                                    ((submitCount)) * sizeof(const VkSubmitInfo2));
                 for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
-                    reservedunmarshal_VkSubmitInfo2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                       (VkSubmitInfo2KHR*)(pSubmits + i),
-                                                       readStreamPtrPtr);
+                    reservedunmarshal_VkSubmitInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                    (VkSubmitInfo2*)(pSubmits + i),
+                                                    readStreamPtrPtr);
                 }
                 uint64_t cgen_var_1;
                 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
@@ -20097,8 +22055,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 *(VkFence*)&fence = (VkFence)unbox_VkFence((VkFence)(*&cgen_var_1));
                 if (pSubmits) {
                     for (uint32_t i = 0; i < (uint32_t)((submitCount)); ++i) {
-                        transform_tohost_VkSubmitInfo2KHR(m_state,
-                                                          (VkSubmitInfo2KHR*)(pSubmits + i));
+                        transform_tohost_VkSubmitInfo2(m_state, (VkSubmitInfo2*)(pSubmits + i));
                     }
                 }
                 if (m_logCalls) {
@@ -20133,7 +22090,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkCmdWriteBufferMarker2AMD: {
                 android::base::beginTrace("vkCmdWriteBufferMarker2AMD decode");
                 VkCommandBuffer commandBuffer;
-                VkPipelineStageFlags2KHR stage;
+                VkPipelineStageFlags2 stage;
                 VkBuffer dstBuffer;
                 VkDeviceSize dstOffset;
                 uint32_t marker;
@@ -20146,9 +22103,9 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
                 auto vk = dispatch_VkCommandBuffer(commandBuffer);
                 // End manual dispatchable handle unboxing for commandBuffer;
-                memcpy((VkPipelineStageFlags2KHR*)&stage, *readStreamPtrPtr,
-                       sizeof(VkPipelineStageFlags2KHR));
-                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2KHR);
+                memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlags2));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
                 uint64_t cgen_var_1;
                 memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
                 *readStreamPtrPtr += 1 * 8;
@@ -20281,6 +22238,8 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 break;
             }
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
@@ -20291,7 +22250,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkCmdCopyBuffer2KHR: {
                 android::base::beginTrace("vkCmdCopyBuffer2KHR decode");
                 VkCommandBuffer commandBuffer;
-                const VkCopyBufferInfo2KHR* pCopyBufferInfo;
+                const VkCopyBufferInfo2* pCopyBufferInfo;
                 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -20301,13 +22260,13 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
                 auto vk = dispatch_VkCommandBuffer(commandBuffer);
                 // End manual dispatchable handle unboxing for commandBuffer;
-                vkReadStream->alloc((void**)&pCopyBufferInfo, sizeof(const VkCopyBufferInfo2KHR));
-                reservedunmarshal_VkCopyBufferInfo2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                       (VkCopyBufferInfo2KHR*)(pCopyBufferInfo),
-                                                       readStreamPtrPtr);
+                vkReadStream->alloc((void**)&pCopyBufferInfo, sizeof(const VkCopyBufferInfo2));
+                reservedunmarshal_VkCopyBufferInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                    (VkCopyBufferInfo2*)(pCopyBufferInfo),
+                                                    readStreamPtrPtr);
                 if (pCopyBufferInfo) {
-                    transform_tohost_VkCopyBufferInfo2KHR(m_state,
-                                                          (VkCopyBufferInfo2KHR*)(pCopyBufferInfo));
+                    transform_tohost_VkCopyBufferInfo2(m_state,
+                                                       (VkCopyBufferInfo2*)(pCopyBufferInfo));
                 }
                 if (m_logCalls) {
                     fprintf(stderr, "stream %p: call vkCmdCopyBuffer2KHR 0x%llx 0x%llx \n",
@@ -20333,7 +22292,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkCmdCopyImage2KHR: {
                 android::base::beginTrace("vkCmdCopyImage2KHR decode");
                 VkCommandBuffer commandBuffer;
-                const VkCopyImageInfo2KHR* pCopyImageInfo;
+                const VkCopyImageInfo2* pCopyImageInfo;
                 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -20343,13 +22302,12 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
                 auto vk = dispatch_VkCommandBuffer(commandBuffer);
                 // End manual dispatchable handle unboxing for commandBuffer;
-                vkReadStream->alloc((void**)&pCopyImageInfo, sizeof(const VkCopyImageInfo2KHR));
-                reservedunmarshal_VkCopyImageInfo2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                      (VkCopyImageInfo2KHR*)(pCopyImageInfo),
-                                                      readStreamPtrPtr);
+                vkReadStream->alloc((void**)&pCopyImageInfo, sizeof(const VkCopyImageInfo2));
+                reservedunmarshal_VkCopyImageInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkCopyImageInfo2*)(pCopyImageInfo),
+                                                   readStreamPtrPtr);
                 if (pCopyImageInfo) {
-                    transform_tohost_VkCopyImageInfo2KHR(m_state,
-                                                         (VkCopyImageInfo2KHR*)(pCopyImageInfo));
+                    transform_tohost_VkCopyImageInfo2(m_state, (VkCopyImageInfo2*)(pCopyImageInfo));
                 }
                 if (m_logCalls) {
                     fprintf(stderr, "stream %p: call vkCmdCopyImage2KHR 0x%llx 0x%llx \n", ioStream,
@@ -20373,7 +22331,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkCmdCopyBufferToImage2KHR: {
                 android::base::beginTrace("vkCmdCopyBufferToImage2KHR decode");
                 VkCommandBuffer commandBuffer;
-                const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo;
+                const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
                 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -20384,13 +22342,13 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto vk = dispatch_VkCommandBuffer(commandBuffer);
                 // End manual dispatchable handle unboxing for commandBuffer;
                 vkReadStream->alloc((void**)&pCopyBufferToImageInfo,
-                                    sizeof(const VkCopyBufferToImageInfo2KHR));
-                reservedunmarshal_VkCopyBufferToImageInfo2KHR(
+                                    sizeof(const VkCopyBufferToImageInfo2));
+                reservedunmarshal_VkCopyBufferToImageInfo2(
                     vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                    (VkCopyBufferToImageInfo2KHR*)(pCopyBufferToImageInfo), readStreamPtrPtr);
+                    (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
                 if (pCopyBufferToImageInfo) {
-                    transform_tohost_VkCopyBufferToImageInfo2KHR(
-                        m_state, (VkCopyBufferToImageInfo2KHR*)(pCopyBufferToImageInfo));
+                    transform_tohost_VkCopyBufferToImageInfo2(
+                        m_state, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
                 }
                 if (m_logCalls) {
                     fprintf(stderr, "stream %p: call vkCmdCopyBufferToImage2KHR 0x%llx 0x%llx \n",
@@ -20416,7 +22374,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkCmdCopyImageToBuffer2KHR: {
                 android::base::beginTrace("vkCmdCopyImageToBuffer2KHR decode");
                 VkCommandBuffer commandBuffer;
-                const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo;
+                const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
                 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -20427,13 +22385,13 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto vk = dispatch_VkCommandBuffer(commandBuffer);
                 // End manual dispatchable handle unboxing for commandBuffer;
                 vkReadStream->alloc((void**)&pCopyImageToBufferInfo,
-                                    sizeof(const VkCopyImageToBufferInfo2KHR));
-                reservedunmarshal_VkCopyImageToBufferInfo2KHR(
+                                    sizeof(const VkCopyImageToBufferInfo2));
+                reservedunmarshal_VkCopyImageToBufferInfo2(
                     vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                    (VkCopyImageToBufferInfo2KHR*)(pCopyImageToBufferInfo), readStreamPtrPtr);
+                    (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
                 if (pCopyImageToBufferInfo) {
-                    transform_tohost_VkCopyImageToBufferInfo2KHR(
-                        m_state, (VkCopyImageToBufferInfo2KHR*)(pCopyImageToBufferInfo));
+                    transform_tohost_VkCopyImageToBufferInfo2(
+                        m_state, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
                 }
                 if (m_logCalls) {
                     fprintf(stderr, "stream %p: call vkCmdCopyImageToBuffer2KHR 0x%llx 0x%llx \n",
@@ -20459,7 +22417,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkCmdBlitImage2KHR: {
                 android::base::beginTrace("vkCmdBlitImage2KHR decode");
                 VkCommandBuffer commandBuffer;
-                const VkBlitImageInfo2KHR* pBlitImageInfo;
+                const VkBlitImageInfo2* pBlitImageInfo;
                 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -20469,13 +22427,12 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
                 auto vk = dispatch_VkCommandBuffer(commandBuffer);
                 // End manual dispatchable handle unboxing for commandBuffer;
-                vkReadStream->alloc((void**)&pBlitImageInfo, sizeof(const VkBlitImageInfo2KHR));
-                reservedunmarshal_VkBlitImageInfo2KHR(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                      (VkBlitImageInfo2KHR*)(pBlitImageInfo),
-                                                      readStreamPtrPtr);
+                vkReadStream->alloc((void**)&pBlitImageInfo, sizeof(const VkBlitImageInfo2));
+                reservedunmarshal_VkBlitImageInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkBlitImageInfo2*)(pBlitImageInfo),
+                                                   readStreamPtrPtr);
                 if (pBlitImageInfo) {
-                    transform_tohost_VkBlitImageInfo2KHR(m_state,
-                                                         (VkBlitImageInfo2KHR*)(pBlitImageInfo));
+                    transform_tohost_VkBlitImageInfo2(m_state, (VkBlitImageInfo2*)(pBlitImageInfo));
                 }
                 if (m_logCalls) {
                     fprintf(stderr, "stream %p: call vkCmdBlitImage2KHR 0x%llx 0x%llx \n", ioStream,
@@ -20499,7 +22456,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkCmdResolveImage2KHR: {
                 android::base::beginTrace("vkCmdResolveImage2KHR decode");
                 VkCommandBuffer commandBuffer;
-                const VkResolveImageInfo2KHR* pResolveImageInfo;
+                const VkResolveImageInfo2* pResolveImageInfo;
                 // Begin non wrapped dispatchable handle unboxing for commandBuffer;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -20509,14 +22466,13 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
                 auto vk = dispatch_VkCommandBuffer(commandBuffer);
                 // End manual dispatchable handle unboxing for commandBuffer;
-                vkReadStream->alloc((void**)&pResolveImageInfo,
-                                    sizeof(const VkResolveImageInfo2KHR));
-                reservedunmarshal_VkResolveImageInfo2KHR(
-                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                    (VkResolveImageInfo2KHR*)(pResolveImageInfo), readStreamPtrPtr);
+                vkReadStream->alloc((void**)&pResolveImageInfo, sizeof(const VkResolveImageInfo2));
+                reservedunmarshal_VkResolveImageInfo2(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                      (VkResolveImageInfo2*)(pResolveImageInfo),
+                                                      readStreamPtrPtr);
                 if (pResolveImageInfo) {
-                    transform_tohost_VkResolveImageInfo2KHR(
-                        m_state, (VkResolveImageInfo2KHR*)(pResolveImageInfo));
+                    transform_tohost_VkResolveImageInfo2(m_state,
+                                                         (VkResolveImageInfo2*)(pResolveImageInfo));
                 }
                 if (m_logCalls) {
                     fprintf(stderr, "stream %p: call vkCmdResolveImage2KHR 0x%llx 0x%llx \n",
@@ -20542,11 +22498,52 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
 #endif
 #ifdef VK_KHR_format_feature_flags2
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+            case OP_vkCmdTraceRaysIndirect2KHR: {
+                android::base::beginTrace("vkCmdTraceRaysIndirect2KHR decode");
+                VkCommandBuffer commandBuffer;
+                VkDeviceAddress indirectDeviceAddress;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkDeviceAddress*)&indirectDeviceAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdTraceRaysIndirect2KHR 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)indirectDeviceAddress);
+                }
+                vk->vkCmdTraceRaysIndirect2KHR(unboxed_commandBuffer, indirectDeviceAddress);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdTraceRaysIndirect2KHR(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        indirectDeviceAddress);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
             case OP_vkGetDeviceBufferMemoryRequirementsKHR: {
                 android::base::beginTrace("vkGetDeviceBufferMemoryRequirementsKHR decode");
                 VkDevice device;
-                const VkDeviceBufferMemoryRequirementsKHR* pInfo;
+                const VkDeviceBufferMemoryRequirements* pInfo;
                 VkMemoryRequirements2* pMemoryRequirements;
                 // Begin non wrapped dispatchable handle unboxing for device;
                 uint64_t cgen_var_0;
@@ -20556,11 +22553,10 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_device = unbox_VkDevice(device);
                 auto vk = dispatch_VkDevice(device);
                 // End manual dispatchable handle unboxing for device;
-                vkReadStream->alloc((void**)&pInfo,
-                                    sizeof(const VkDeviceBufferMemoryRequirementsKHR));
-                reservedunmarshal_VkDeviceBufferMemoryRequirementsKHR(
+                vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceBufferMemoryRequirements));
+                reservedunmarshal_VkDeviceBufferMemoryRequirements(
                     vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                    (VkDeviceBufferMemoryRequirementsKHR*)(pInfo), readStreamPtrPtr);
+                    (VkDeviceBufferMemoryRequirements*)(pInfo), readStreamPtrPtr);
                 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
                 vkReadStream->unsetHandleMapping();
                 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements2));
@@ -20568,8 +22564,8 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                     vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
                     (VkMemoryRequirements2*)(pMemoryRequirements), readStreamPtrPtr);
                 if (pInfo) {
-                    transform_tohost_VkDeviceBufferMemoryRequirementsKHR(
-                        m_state, (VkDeviceBufferMemoryRequirementsKHR*)(pInfo));
+                    transform_tohost_VkDeviceBufferMemoryRequirements(
+                        m_state, (VkDeviceBufferMemoryRequirements*)(pInfo));
                 }
                 if (pMemoryRequirements) {
                     transform_tohost_VkMemoryRequirements2(
@@ -20609,7 +22605,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkGetDeviceImageMemoryRequirementsKHR: {
                 android::base::beginTrace("vkGetDeviceImageMemoryRequirementsKHR decode");
                 VkDevice device;
-                const VkDeviceImageMemoryRequirementsKHR* pInfo;
+                const VkDeviceImageMemoryRequirements* pInfo;
                 VkMemoryRequirements2* pMemoryRequirements;
                 // Begin non wrapped dispatchable handle unboxing for device;
                 uint64_t cgen_var_0;
@@ -20619,11 +22615,10 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_device = unbox_VkDevice(device);
                 auto vk = dispatch_VkDevice(device);
                 // End manual dispatchable handle unboxing for device;
-                vkReadStream->alloc((void**)&pInfo,
-                                    sizeof(const VkDeviceImageMemoryRequirementsKHR));
-                reservedunmarshal_VkDeviceImageMemoryRequirementsKHR(
+                vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceImageMemoryRequirements));
+                reservedunmarshal_VkDeviceImageMemoryRequirements(
                     vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                    (VkDeviceImageMemoryRequirementsKHR*)(pInfo), readStreamPtrPtr);
+                    (VkDeviceImageMemoryRequirements*)(pInfo), readStreamPtrPtr);
                 // Begin manual dispatchable handle unboxing for pMemoryRequirements;
                 vkReadStream->unsetHandleMapping();
                 vkReadStream->alloc((void**)&pMemoryRequirements, sizeof(VkMemoryRequirements2));
@@ -20631,8 +22626,8 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                     vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
                     (VkMemoryRequirements2*)(pMemoryRequirements), readStreamPtrPtr);
                 if (pInfo) {
-                    transform_tohost_VkDeviceImageMemoryRequirementsKHR(
-                        m_state, (VkDeviceImageMemoryRequirementsKHR*)(pInfo));
+                    transform_tohost_VkDeviceImageMemoryRequirements(
+                        m_state, (VkDeviceImageMemoryRequirements*)(pInfo));
                 }
                 if (pMemoryRequirements) {
                     transform_tohost_VkMemoryRequirements2(
@@ -20672,7 +22667,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkGetDeviceImageSparseMemoryRequirementsKHR: {
                 android::base::beginTrace("vkGetDeviceImageSparseMemoryRequirementsKHR decode");
                 VkDevice device;
-                const VkDeviceImageMemoryRequirementsKHR* pInfo;
+                const VkDeviceImageMemoryRequirements* pInfo;
                 uint32_t* pSparseMemoryRequirementCount;
                 VkSparseImageMemoryRequirements2* pSparseMemoryRequirements;
                 // Begin non wrapped dispatchable handle unboxing for device;
@@ -20683,11 +22678,10 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_device = unbox_VkDevice(device);
                 auto vk = dispatch_VkDevice(device);
                 // End manual dispatchable handle unboxing for device;
-                vkReadStream->alloc((void**)&pInfo,
-                                    sizeof(const VkDeviceImageMemoryRequirementsKHR));
-                reservedunmarshal_VkDeviceImageMemoryRequirementsKHR(
+                vkReadStream->alloc((void**)&pInfo, sizeof(const VkDeviceImageMemoryRequirements));
+                reservedunmarshal_VkDeviceImageMemoryRequirements(
                     vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                    (VkDeviceImageMemoryRequirementsKHR*)(pInfo), readStreamPtrPtr);
+                    (VkDeviceImageMemoryRequirements*)(pInfo), readStreamPtrPtr);
                 // Begin manual dispatchable handle unboxing for pSparseMemoryRequirementCount;
                 vkReadStream->unsetHandleMapping();
                 // WARNING PTR CHECK
@@ -20719,8 +22713,8 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                     }
                 }
                 if (pInfo) {
-                    transform_tohost_VkDeviceImageMemoryRequirementsKHR(
-                        m_state, (VkDeviceImageMemoryRequirementsKHR*)(pInfo));
+                    transform_tohost_VkDeviceImageMemoryRequirements(
+                        m_state, (VkDeviceImageMemoryRequirements*)(pInfo));
                 }
                 if (pSparseMemoryRequirementCount) {
                     if (pSparseMemoryRequirements) {
@@ -20789,6 +22783,8 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 break;
             }
 #endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+#endif
 #ifdef VK_ANDROID_native_buffer
             case OP_vkGetSwapchainGrallocUsageANDROID: {
                 android::base::beginTrace("vkGetSwapchainGrallocUsageANDROID decode");
@@ -20920,22 +22916,16 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
                 memcpy((uint32_t*)&waitSemaphoreCount, *readStreamPtrPtr, sizeof(uint32_t));
                 *readStreamPtrPtr += sizeof(uint32_t);
-                // WARNING PTR CHECK
-                memcpy((VkSemaphore**)&pWaitSemaphores, (*readStreamPtrPtr), 8);
-                android::base::Stream::fromBe64((uint8_t*)&pWaitSemaphores);
-                *readStreamPtrPtr += 8;
-                if (pWaitSemaphores) {
-                    vkReadStream->alloc((void**)&pWaitSemaphores,
-                                        ((waitSemaphoreCount)) * sizeof(const VkSemaphore));
-                    if (((waitSemaphoreCount))) {
-                        uint8_t* cgen_var_1_0_ptr = (uint8_t*)(*readStreamPtrPtr);
-                        *readStreamPtrPtr += 8 * ((waitSemaphoreCount));
-                        for (uint32_t k = 0; k < ((waitSemaphoreCount)); ++k) {
-                            uint64_t tmpval;
-                            memcpy(&tmpval, cgen_var_1_0_ptr + k * 8, sizeof(uint64_t));
-                            *(((VkSemaphore*)pWaitSemaphores) + k) =
-                                (VkSemaphore)unbox_VkSemaphore((VkSemaphore)tmpval);
-                        }
+                vkReadStream->alloc((void**)&pWaitSemaphores,
+                                    ((waitSemaphoreCount)) * sizeof(const VkSemaphore));
+                if (((waitSemaphoreCount))) {
+                    uint8_t* cgen_var_1_ptr = (uint8_t*)(*readStreamPtrPtr);
+                    *readStreamPtrPtr += 8 * ((waitSemaphoreCount));
+                    for (uint32_t k = 0; k < ((waitSemaphoreCount)); ++k) {
+                        uint64_t tmpval;
+                        memcpy(&tmpval, cgen_var_1_ptr + k * 8, sizeof(uint64_t));
+                        *(((VkSemaphore*)pWaitSemaphores) + k) =
+                            (VkSemaphore)unbox_VkSemaphore((VkSemaphore)tmpval);
                     }
                 }
                 uint64_t cgen_var_2;
@@ -20984,6 +22974,77 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 android::base::endTrace();
                 break;
             }
+            case OP_vkGetSwapchainGrallocUsage2ANDROID: {
+                android::base::beginTrace("vkGetSwapchainGrallocUsage2ANDROID decode");
+                VkDevice device;
+                VkFormat format;
+                VkImageUsageFlags imageUsage;
+                VkSwapchainImageUsageFlagsANDROID swapchainImageUsage;
+                uint64_t* grallocConsumerUsage;
+                uint64_t* grallocProducerUsage;
+                // Begin global wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                memcpy((VkFormat*)&format, *readStreamPtrPtr, sizeof(VkFormat));
+                *readStreamPtrPtr += sizeof(VkFormat);
+                memcpy((VkImageUsageFlags*)&imageUsage, *readStreamPtrPtr,
+                       sizeof(VkImageUsageFlags));
+                *readStreamPtrPtr += sizeof(VkImageUsageFlags);
+                memcpy((VkSwapchainImageUsageFlagsANDROID*)&swapchainImageUsage, *readStreamPtrPtr,
+                       sizeof(VkSwapchainImageUsageFlagsANDROID));
+                *readStreamPtrPtr += sizeof(VkSwapchainImageUsageFlagsANDROID);
+                // Begin manual dispatchable handle unboxing for grallocConsumerUsage;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&grallocConsumerUsage, sizeof(uint64_t));
+                memcpy((uint64_t*)grallocConsumerUsage, *readStreamPtrPtr, sizeof(uint64_t));
+                *readStreamPtrPtr += sizeof(uint64_t);
+                // Begin manual dispatchable handle unboxing for grallocProducerUsage;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&grallocProducerUsage, sizeof(uint64_t));
+                memcpy((uint64_t*)grallocProducerUsage, *readStreamPtrPtr, sizeof(uint64_t));
+                *readStreamPtrPtr += sizeof(uint64_t);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetSwapchainGrallocUsage2ANDROID 0x%llx 0x%llx "
+                            "0x%llx 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)format,
+                            (unsigned long long)imageUsage, (unsigned long long)swapchainImageUsage,
+                            (unsigned long long)grallocConsumerUsage,
+                            (unsigned long long)grallocProducerUsage);
+                }
+                VkResult vkGetSwapchainGrallocUsage2ANDROID_VkResult_return = (VkResult)0;
+                vkGetSwapchainGrallocUsage2ANDROID_VkResult_return =
+                    m_state->on_vkGetSwapchainGrallocUsage2ANDROID(
+                        &m_pool, device, format, imageUsage, swapchainImageUsage,
+                        grallocConsumerUsage, grallocProducerUsage);
+                if ((vkGetSwapchainGrallocUsage2ANDROID_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkGetSwapchainGrallocUsage2ANDROID_VkResult_return,
+                                             opcode, context);
+                vkStream->unsetHandleMapping();
+                vkStream->write((uint64_t*)grallocConsumerUsage, sizeof(uint64_t));
+                vkStream->write((uint64_t*)grallocProducerUsage, sizeof(uint64_t));
+                vkStream->write(&vkGetSwapchainGrallocUsage2ANDROID_VkResult_return,
+                                sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetSwapchainGrallocUsage2ANDROID(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkGetSwapchainGrallocUsage2ANDROID_VkResult_return, device, format,
+                        imageUsage, swapchainImageUsage, grallocConsumerUsage,
+                        grallocProducerUsage);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
 #endif
 #ifdef VK_EXT_debug_report
             case OP_vkCreateDebugReportCallbackEXT: {
@@ -22361,8 +24422,6 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
 #endif
 #ifdef VK_EXT_video_encode_h265
 #endif
-#ifdef VK_EXT_video_decode_h264
-#endif
 #ifdef VK_AMD_texture_gather_bias_lod
 #endif
 #ifdef VK_AMD_shader_info
@@ -22804,6 +24863,8 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
 #endif
 #ifdef VK_EXT_astc_decode_mode
 #endif
+#ifdef VK_EXT_pipeline_robustness
+#endif
 #ifdef VK_EXT_conditional_rendering
             case OP_vkCmdBeginConditionalRenderingEXT: {
                 android::base::beginTrace("vkCmdBeginConditionalRenderingEXT decode");
@@ -23730,6 +25791,82 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 android::base::endTrace();
                 break;
             }
+            case OP_vkCmdSetDiscardRectangleEnableEXT: {
+                android::base::beginTrace("vkCmdSetDiscardRectangleEnableEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 discardRectangleEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&discardRectangleEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetDiscardRectangleEnableEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)discardRectangleEnable);
+                }
+                vk->vkCmdSetDiscardRectangleEnableEXT(unboxed_commandBuffer,
+                                                      discardRectangleEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetDiscardRectangleEnableEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        discardRectangleEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDiscardRectangleModeEXT: {
+                android::base::beginTrace("vkCmdSetDiscardRectangleModeEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkDiscardRectangleModeEXT discardRectangleMode;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkDiscardRectangleModeEXT*)&discardRectangleMode, *readStreamPtrPtr,
+                       sizeof(VkDiscardRectangleModeEXT));
+                *readStreamPtrPtr += sizeof(VkDiscardRectangleModeEXT);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetDiscardRectangleModeEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)discardRectangleMode);
+                }
+                vk->vkCmdSetDiscardRectangleModeEXT(unboxed_commandBuffer, discardRectangleMode);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetDiscardRectangleModeEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        discardRectangleMode);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
 #endif
 #ifdef VK_EXT_conservative_rasterization
 #endif
@@ -23965,229 +26102,6 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 break;
             }
 #endif
-#ifdef VK_MVK_moltenvk
-            case OP_vkGetMTLDeviceMVK: {
-                android::base::beginTrace("vkGetMTLDeviceMVK decode");
-                VkPhysicalDevice physicalDevice;
-                void** pMTLDevice;
-                // Begin non wrapped dispatchable handle unboxing for physicalDevice;
-                uint64_t cgen_var_0;
-                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
-                *readStreamPtrPtr += 1 * 8;
-                *(VkPhysicalDevice*)&physicalDevice =
-                    (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
-                auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
-                auto vk = dispatch_VkPhysicalDevice(physicalDevice);
-                // End manual dispatchable handle unboxing for physicalDevice;
-                // Begin manual dispatchable handle unboxing for pMTLDevice;
-                vkReadStream->unsetHandleMapping();
-                vkReadStream->alloc((void**)&pMTLDevice, sizeof(void*));
-                memcpy((void**)pMTLDevice, *readStreamPtrPtr, sizeof(void*));
-                *readStreamPtrPtr += sizeof(void*);
-                if (m_logCalls) {
-                    fprintf(stderr, "stream %p: call vkGetMTLDeviceMVK 0x%llx 0x%llx \n", ioStream,
-                            (unsigned long long)physicalDevice, (unsigned long long)pMTLDevice);
-                }
-                vk->vkGetMTLDeviceMVK(unboxed_physicalDevice, pMTLDevice);
-                vkStream->unsetHandleMapping();
-                vkStream->write((void**)pMTLDevice, sizeof(void*));
-                vkStream->commitWrite();
-                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
-                                         (uintptr_t)snapshotTraceBegin);
-                size_t snapshotTraceBytes = vkReadStream->endTrace();
-                if (m_state->snapshotsEnabled()) {
-                    m_state->snapshot()->vkGetMTLDeviceMVK(snapshotTraceBegin, snapshotTraceBytes,
-                                                           &m_pool, physicalDevice, pMTLDevice);
-                }
-                vkReadStream->clearPool();
-                if (queueSubmitWithCommandsEnabled)
-                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
-                android::base::endTrace();
-                break;
-            }
-            case OP_vkSetMTLTextureMVK: {
-                android::base::beginTrace("vkSetMTLTextureMVK decode");
-                VkImage image;
-                void* mtlTexture;
-                uint64_t cgen_var_0;
-                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
-                *readStreamPtrPtr += 1 * 8;
-                *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
-                // Begin manual dispatchable handle unboxing for mtlTexture;
-                vkReadStream->unsetHandleMapping();
-                vkReadStream->alloc((void**)&mtlTexture, sizeof(uint8_t));
-                memcpy((void*)mtlTexture, *readStreamPtrPtr, sizeof(uint8_t));
-                *readStreamPtrPtr += sizeof(uint8_t);
-                if (m_logCalls) {
-                    fprintf(stderr, "stream %p: call vkSetMTLTextureMVK 0x%llx 0x%llx \n", ioStream,
-                            (unsigned long long)image, (unsigned long long)mtlTexture);
-                }
-                VkResult vkSetMTLTextureMVK_VkResult_return = (VkResult)0;
-                vkSetMTLTextureMVK_VkResult_return = vk->vkSetMTLTextureMVK(image, mtlTexture);
-                if ((vkSetMTLTextureMVK_VkResult_return) == VK_ERROR_DEVICE_LOST)
-                    m_state->on_DeviceLost();
-                m_state->on_CheckOutOfMemory(vkSetMTLTextureMVK_VkResult_return, opcode, context);
-                vkStream->unsetHandleMapping();
-                vkStream->write((void*)mtlTexture, sizeof(uint8_t));
-                vkStream->write(&vkSetMTLTextureMVK_VkResult_return, sizeof(VkResult));
-                vkStream->commitWrite();
-                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
-                                         (uintptr_t)snapshotTraceBegin);
-                size_t snapshotTraceBytes = vkReadStream->endTrace();
-                if (m_state->snapshotsEnabled()) {
-                    m_state->snapshot()->vkSetMTLTextureMVK(
-                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
-                        vkSetMTLTextureMVK_VkResult_return, image, mtlTexture);
-                }
-                vkReadStream->clearPool();
-                if (queueSubmitWithCommandsEnabled)
-                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
-                android::base::endTrace();
-                break;
-            }
-            case OP_vkGetMTLTextureMVK: {
-                android::base::beginTrace("vkGetMTLTextureMVK decode");
-                VkImage image;
-                void** pMTLTexture;
-                uint64_t cgen_var_0;
-                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
-                *readStreamPtrPtr += 1 * 8;
-                *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
-                // Begin manual dispatchable handle unboxing for pMTLTexture;
-                vkReadStream->unsetHandleMapping();
-                vkReadStream->alloc((void**)&pMTLTexture, sizeof(void*));
-                memcpy((void**)pMTLTexture, *readStreamPtrPtr, sizeof(void*));
-                *readStreamPtrPtr += sizeof(void*);
-                if (m_logCalls) {
-                    fprintf(stderr, "stream %p: call vkGetMTLTextureMVK 0x%llx 0x%llx \n", ioStream,
-                            (unsigned long long)image, (unsigned long long)pMTLTexture);
-                }
-                vk->vkGetMTLTextureMVK(image, pMTLTexture);
-                vkStream->unsetHandleMapping();
-                vkStream->write((void**)pMTLTexture, sizeof(void*));
-                vkStream->commitWrite();
-                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
-                                         (uintptr_t)snapshotTraceBegin);
-                size_t snapshotTraceBytes = vkReadStream->endTrace();
-                if (m_state->snapshotsEnabled()) {
-                    m_state->snapshot()->vkGetMTLTextureMVK(snapshotTraceBegin, snapshotTraceBytes,
-                                                            &m_pool, image, pMTLTexture);
-                }
-                vkReadStream->clearPool();
-                if (queueSubmitWithCommandsEnabled)
-                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
-                android::base::endTrace();
-                break;
-            }
-            case OP_vkGetMTLBufferMVK: {
-                android::base::beginTrace("vkGetMTLBufferMVK decode");
-                VkBuffer buffer;
-                void** pMTLBuffer;
-                uint64_t cgen_var_0;
-                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
-                *readStreamPtrPtr += 1 * 8;
-                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
-                // Begin manual dispatchable handle unboxing for pMTLBuffer;
-                vkReadStream->unsetHandleMapping();
-                vkReadStream->alloc((void**)&pMTLBuffer, sizeof(void*));
-                memcpy((void**)pMTLBuffer, *readStreamPtrPtr, sizeof(void*));
-                *readStreamPtrPtr += sizeof(void*);
-                if (m_logCalls) {
-                    fprintf(stderr, "stream %p: call vkGetMTLBufferMVK 0x%llx 0x%llx \n", ioStream,
-                            (unsigned long long)buffer, (unsigned long long)pMTLBuffer);
-                }
-                vk->vkGetMTLBufferMVK(buffer, pMTLBuffer);
-                vkStream->unsetHandleMapping();
-                vkStream->write((void**)pMTLBuffer, sizeof(void*));
-                vkStream->commitWrite();
-                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
-                                         (uintptr_t)snapshotTraceBegin);
-                size_t snapshotTraceBytes = vkReadStream->endTrace();
-                if (m_state->snapshotsEnabled()) {
-                    m_state->snapshot()->vkGetMTLBufferMVK(snapshotTraceBegin, snapshotTraceBytes,
-                                                           &m_pool, buffer, pMTLBuffer);
-                }
-                vkReadStream->clearPool();
-                if (queueSubmitWithCommandsEnabled)
-                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
-                android::base::endTrace();
-                break;
-            }
-            case OP_vkUseIOSurfaceMVK: {
-                android::base::beginTrace("vkUseIOSurfaceMVK decode");
-                VkImage image;
-                void* ioSurface;
-                uint64_t cgen_var_0;
-                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
-                *readStreamPtrPtr += 1 * 8;
-                *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
-                // Begin manual dispatchable handle unboxing for ioSurface;
-                vkReadStream->unsetHandleMapping();
-                vkReadStream->alloc((void**)&ioSurface, sizeof(uint8_t));
-                memcpy((void*)ioSurface, *readStreamPtrPtr, sizeof(uint8_t));
-                *readStreamPtrPtr += sizeof(uint8_t);
-                if (m_logCalls) {
-                    fprintf(stderr, "stream %p: call vkUseIOSurfaceMVK 0x%llx 0x%llx \n", ioStream,
-                            (unsigned long long)image, (unsigned long long)ioSurface);
-                }
-                VkResult vkUseIOSurfaceMVK_VkResult_return = (VkResult)0;
-                vkUseIOSurfaceMVK_VkResult_return = vk->vkUseIOSurfaceMVK(image, ioSurface);
-                if ((vkUseIOSurfaceMVK_VkResult_return) == VK_ERROR_DEVICE_LOST)
-                    m_state->on_DeviceLost();
-                m_state->on_CheckOutOfMemory(vkUseIOSurfaceMVK_VkResult_return, opcode, context);
-                vkStream->unsetHandleMapping();
-                vkStream->write((void*)ioSurface, sizeof(uint8_t));
-                vkStream->write(&vkUseIOSurfaceMVK_VkResult_return, sizeof(VkResult));
-                vkStream->commitWrite();
-                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
-                                         (uintptr_t)snapshotTraceBegin);
-                size_t snapshotTraceBytes = vkReadStream->endTrace();
-                if (m_state->snapshotsEnabled()) {
-                    m_state->snapshot()->vkUseIOSurfaceMVK(
-                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
-                        vkUseIOSurfaceMVK_VkResult_return, image, ioSurface);
-                }
-                vkReadStream->clearPool();
-                if (queueSubmitWithCommandsEnabled)
-                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
-                android::base::endTrace();
-                break;
-            }
-            case OP_vkGetIOSurfaceMVK: {
-                android::base::beginTrace("vkGetIOSurfaceMVK decode");
-                VkImage image;
-                void** pIOSurface;
-                uint64_t cgen_var_0;
-                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
-                *readStreamPtrPtr += 1 * 8;
-                *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
-                // Begin manual dispatchable handle unboxing for pIOSurface;
-                vkReadStream->unsetHandleMapping();
-                vkReadStream->alloc((void**)&pIOSurface, sizeof(void*));
-                memcpy((void**)pIOSurface, *readStreamPtrPtr, sizeof(void*));
-                *readStreamPtrPtr += sizeof(void*);
-                if (m_logCalls) {
-                    fprintf(stderr, "stream %p: call vkGetIOSurfaceMVK 0x%llx 0x%llx \n", ioStream,
-                            (unsigned long long)image, (unsigned long long)pIOSurface);
-                }
-                vk->vkGetIOSurfaceMVK(image, pIOSurface);
-                vkStream->unsetHandleMapping();
-                vkStream->write((void**)pIOSurface, sizeof(void*));
-                vkStream->commitWrite();
-                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
-                                         (uintptr_t)snapshotTraceBegin);
-                size_t snapshotTraceBytes = vkReadStream->endTrace();
-                if (m_state->snapshotsEnabled()) {
-                    m_state->snapshot()->vkGetIOSurfaceMVK(snapshotTraceBegin, snapshotTraceBytes,
-                                                           &m_pool, image, pIOSurface);
-                }
-                vkReadStream->clearPool();
-                if (queueSubmitWithCommandsEnabled)
-                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
-                android::base::endTrace();
-                break;
-            }
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -26805,8 +28719,6 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
 #endif
 #ifdef VK_AMD_shader_core_properties
 #endif
-#ifdef VK_EXT_video_decode_h265
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 #endif
 #ifdef VK_EXT_vertex_attribute_divisor
@@ -26977,6 +28889,57 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
 #ifdef VK_NV_shader_image_footprint
 #endif
 #ifdef VK_NV_scissor_exclusive
+            case OP_vkCmdSetExclusiveScissorEnableNV: {
+                android::base::beginTrace("vkCmdSetExclusiveScissorEnableNV decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t firstExclusiveScissor;
+                uint32_t exclusiveScissorCount;
+                const VkBool32* pExclusiveScissorEnables;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&firstExclusiveScissor, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&exclusiveScissorCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pExclusiveScissorEnables,
+                                    ((exclusiveScissorCount)) * sizeof(const VkBool32));
+                memcpy((VkBool32*)pExclusiveScissorEnables, *readStreamPtrPtr,
+                       ((exclusiveScissorCount)) * sizeof(const VkBool32));
+                *readStreamPtrPtr += ((exclusiveScissorCount)) * sizeof(const VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetExclusiveScissorEnableNV 0x%llx 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)firstExclusiveScissor,
+                            (unsigned long long)exclusiveScissorCount,
+                            (unsigned long long)pExclusiveScissorEnables);
+                }
+                vk->vkCmdSetExclusiveScissorEnableNV(unboxed_commandBuffer, firstExclusiveScissor,
+                                                     exclusiveScissorCount,
+                                                     pExclusiveScissorEnables);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetExclusiveScissorEnableNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
             case OP_vkCmdSetExclusiveScissorNV: {
                 android::base::beginTrace("vkCmdSetExclusiveScissorNV decode");
                 VkCommandBuffer commandBuffer;
@@ -27862,7 +29825,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 android::base::beginTrace("vkGetPhysicalDeviceToolPropertiesEXT decode");
                 VkPhysicalDevice physicalDevice;
                 uint32_t* pToolCount;
-                VkPhysicalDeviceToolPropertiesEXT* pToolProperties;
+                VkPhysicalDeviceToolProperties* pToolProperties;
                 // Begin non wrapped dispatchable handle unboxing for physicalDevice;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -27886,26 +29849,24 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 // Begin manual dispatchable handle unboxing for pToolProperties;
                 vkReadStream->unsetHandleMapping();
                 // WARNING PTR CHECK
-                memcpy((VkPhysicalDeviceToolPropertiesEXT**)&pToolProperties, (*readStreamPtrPtr),
-                       8);
+                memcpy((VkPhysicalDeviceToolProperties**)&pToolProperties, (*readStreamPtrPtr), 8);
                 android::base::Stream::fromBe64((uint8_t*)&pToolProperties);
                 *readStreamPtrPtr += 8;
                 if (pToolProperties) {
-                    vkReadStream->alloc(
-                        (void**)&pToolProperties,
-                        (*(pToolCount)) * sizeof(VkPhysicalDeviceToolPropertiesEXT));
+                    vkReadStream->alloc((void**)&pToolProperties,
+                                        (*(pToolCount)) * sizeof(VkPhysicalDeviceToolProperties));
                     for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
-                        reservedunmarshal_VkPhysicalDeviceToolPropertiesEXT(
+                        reservedunmarshal_VkPhysicalDeviceToolProperties(
                             vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                            (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i),
+                            (VkPhysicalDeviceToolProperties*)(pToolProperties + i),
                             readStreamPtrPtr);
                     }
                 }
                 if (pToolCount) {
                     if (pToolProperties) {
                         for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
-                            transform_tohost_VkPhysicalDeviceToolPropertiesEXT(
-                                m_state, (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i));
+                            transform_tohost_VkPhysicalDeviceToolProperties(
+                                m_state, (VkPhysicalDeviceToolProperties*)(pToolProperties + i));
                         }
                     }
                 }
@@ -27934,8 +29895,8 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 if (pToolCount) {
                     if (pToolProperties) {
                         for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
-                            transform_fromhost_VkPhysicalDeviceToolPropertiesEXT(
-                                m_state, (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i));
+                            transform_fromhost_VkPhysicalDeviceToolProperties(
+                                m_state, (VkPhysicalDeviceToolProperties*)(pToolProperties + i));
                         }
                     }
                 }
@@ -27945,9 +29906,9 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 if (pToolProperties) {
                     if (pToolCount) {
                         for (uint32_t i = 0; i < (uint32_t)(*(pToolCount)); ++i) {
-                            marshal_VkPhysicalDeviceToolPropertiesEXT(
+                            marshal_VkPhysicalDeviceToolProperties(
                                 vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                (VkPhysicalDeviceToolPropertiesEXT*)(pToolProperties + i));
+                                (VkPhysicalDeviceToolProperties*)(pToolProperties + i));
                         }
                     }
                 }
@@ -29201,6 +31162,59 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
 #endif
 #ifdef VK_EXT_shader_atomic_float2
 #endif
+#ifdef VK_EXT_surface_maintenance1
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+            case OP_vkReleaseSwapchainImagesEXT: {
+                android::base::beginTrace("vkReleaseSwapchainImagesEXT decode");
+                VkDevice device;
+                const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pReleaseInfo,
+                                    sizeof(const VkReleaseSwapchainImagesInfoEXT));
+                reservedunmarshal_VkReleaseSwapchainImagesInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkReleaseSwapchainImagesInfoEXT*)(pReleaseInfo), readStreamPtrPtr);
+                if (pReleaseInfo) {
+                    transform_tohost_VkReleaseSwapchainImagesInfoEXT(
+                        m_state, (VkReleaseSwapchainImagesInfoEXT*)(pReleaseInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkReleaseSwapchainImagesEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pReleaseInfo);
+                }
+                VkResult vkReleaseSwapchainImagesEXT_VkResult_return = (VkResult)0;
+                vkReleaseSwapchainImagesEXT_VkResult_return =
+                    vk->vkReleaseSwapchainImagesEXT(unboxed_device, pReleaseInfo);
+                if ((vkReleaseSwapchainImagesEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkReleaseSwapchainImagesEXT_VkResult_return, opcode,
+                                             context);
+                vkStream->unsetHandleMapping();
+                vkStream->write(&vkReleaseSwapchainImagesEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkReleaseSwapchainImagesEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkReleaseSwapchainImagesEXT_VkResult_return, device, pReleaseInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -29695,13 +31709,15 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+#endif
 #ifdef VK_EXT_private_data
             case OP_vkCreatePrivateDataSlotEXT: {
                 android::base::beginTrace("vkCreatePrivateDataSlotEXT decode");
                 VkDevice device;
-                const VkPrivateDataSlotCreateInfoEXT* pCreateInfo;
+                const VkPrivateDataSlotCreateInfo* pCreateInfo;
                 const VkAllocationCallbacks* pAllocator;
-                VkPrivateDataSlotEXT* pPrivateDataSlot;
+                VkPrivateDataSlot* pPrivateDataSlot;
                 // Begin non wrapped dispatchable handle unboxing for device;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
@@ -29711,10 +31727,10 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto vk = dispatch_VkDevice(device);
                 // End manual dispatchable handle unboxing for device;
                 vkReadStream->alloc((void**)&pCreateInfo,
-                                    sizeof(const VkPrivateDataSlotCreateInfoEXT));
-                reservedunmarshal_VkPrivateDataSlotCreateInfoEXT(
+                                    sizeof(const VkPrivateDataSlotCreateInfo));
+                reservedunmarshal_VkPrivateDataSlotCreateInfo(
                     vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                    (VkPrivateDataSlotCreateInfoEXT*)(pCreateInfo), readStreamPtrPtr);
+                    (VkPrivateDataSlotCreateInfo*)(pCreateInfo), readStreamPtrPtr);
                 // WARNING PTR CHECK
                 memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
                 android::base::Stream::fromBe64((uint8_t*)&pAllocator);
@@ -29727,13 +31743,13 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 }
                 // Begin manual dispatchable handle unboxing for pPrivateDataSlot;
                 vkReadStream->unsetHandleMapping();
-                vkReadStream->alloc((void**)&pPrivateDataSlot, sizeof(VkPrivateDataSlotEXT));
-                memcpy((VkPrivateDataSlotEXT*)&(*pPrivateDataSlot), (*readStreamPtrPtr), 8);
+                vkReadStream->alloc((void**)&pPrivateDataSlot, sizeof(VkPrivateDataSlot));
+                memcpy((VkPrivateDataSlot*)&(*pPrivateDataSlot), (*readStreamPtrPtr), 8);
                 android::base::Stream::fromBe64((uint8_t*)&(*pPrivateDataSlot));
                 *readStreamPtrPtr += 8;
                 if (pCreateInfo) {
-                    transform_tohost_VkPrivateDataSlotCreateInfoEXT(
-                        m_state, (VkPrivateDataSlotCreateInfoEXT*)(pCreateInfo));
+                    transform_tohost_VkPrivateDataSlotCreateInfo(
+                        m_state, (VkPrivateDataSlotCreateInfo*)(pCreateInfo));
                 }
                 if (pAllocator) {
                     transform_tohost_VkAllocationCallbacks(m_state,
@@ -29776,7 +31792,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
             case OP_vkDestroyPrivateDataSlotEXT: {
                 android::base::beginTrace("vkDestroyPrivateDataSlotEXT decode");
                 VkDevice device;
-                VkPrivateDataSlotEXT privateDataSlot;
+                VkPrivateDataSlot privateDataSlot;
                 const VkAllocationCallbacks* pAllocator;
                 // Begin non wrapped dispatchable handle unboxing for device;
                 uint64_t cgen_var_0;
@@ -29786,7 +31802,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 auto unboxed_device = unbox_VkDevice(device);
                 auto vk = dispatch_VkDevice(device);
                 // End manual dispatchable handle unboxing for device;
-                memcpy((VkPrivateDataSlotEXT*)&privateDataSlot, (*readStreamPtrPtr), 8);
+                memcpy((VkPrivateDataSlot*)&privateDataSlot, (*readStreamPtrPtr), 8);
                 android::base::Stream::fromBe64((uint8_t*)&privateDataSlot);
                 *readStreamPtrPtr += 8;
                 // WARNING PTR CHECK
@@ -29830,7 +31846,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 VkDevice device;
                 VkObjectType objectType;
                 uint64_t objectHandle;
-                VkPrivateDataSlotEXT privateDataSlot;
+                VkPrivateDataSlot privateDataSlot;
                 uint64_t data;
                 // Begin non wrapped dispatchable handle unboxing for device;
                 uint64_t cgen_var_0;
@@ -29844,7 +31860,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 *readStreamPtrPtr += sizeof(VkObjectType);
                 memcpy((uint64_t*)&objectHandle, *readStreamPtrPtr, sizeof(uint64_t));
                 *readStreamPtrPtr += sizeof(uint64_t);
-                memcpy((VkPrivateDataSlotEXT*)&privateDataSlot, (*readStreamPtrPtr), 8);
+                memcpy((VkPrivateDataSlot*)&privateDataSlot, (*readStreamPtrPtr), 8);
                 android::base::Stream::fromBe64((uint8_t*)&privateDataSlot);
                 *readStreamPtrPtr += 8;
                 memcpy((uint64_t*)&data, *readStreamPtrPtr, sizeof(uint64_t));
@@ -29886,7 +31902,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 VkDevice device;
                 VkObjectType objectType;
                 uint64_t objectHandle;
-                VkPrivateDataSlotEXT privateDataSlot;
+                VkPrivateDataSlot privateDataSlot;
                 uint64_t* pData;
                 // Begin non wrapped dispatchable handle unboxing for device;
                 uint64_t cgen_var_0;
@@ -29900,7 +31916,7 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 *readStreamPtrPtr += sizeof(VkObjectType);
                 memcpy((uint64_t*)&objectHandle, *readStreamPtrPtr, sizeof(uint64_t));
                 *readStreamPtrPtr += sizeof(uint64_t);
-                memcpy((VkPrivateDataSlotEXT*)&privateDataSlot, (*readStreamPtrPtr), 8);
+                memcpy((VkPrivateDataSlot*)&privateDataSlot, (*readStreamPtrPtr), 8);
                 android::base::Stream::fromBe64((uint8_t*)&privateDataSlot);
                 *readStreamPtrPtr += 8;
                 // Begin manual dispatchable handle unboxing for pData;
@@ -29942,6 +31958,709 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+#endif
+#ifdef VK_EXT_metal_objects
+            case OP_vkExportMetalObjectsEXT: {
+                android::base::beginTrace("vkExportMetalObjectsEXT decode");
+                VkDevice device;
+                VkExportMetalObjectsInfoEXT* pMetalObjectsInfo;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                // Begin manual dispatchable handle unboxing for pMetalObjectsInfo;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pMetalObjectsInfo,
+                                    sizeof(VkExportMetalObjectsInfoEXT));
+                reservedunmarshal_VkExportMetalObjectsInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkExportMetalObjectsInfoEXT*)(pMetalObjectsInfo), readStreamPtrPtr);
+                if (pMetalObjectsInfo) {
+                    transform_tohost_VkExportMetalObjectsInfoEXT(
+                        m_state, (VkExportMetalObjectsInfoEXT*)(pMetalObjectsInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkExportMetalObjectsEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device,
+                            (unsigned long long)pMetalObjectsInfo);
+                }
+                vk->vkExportMetalObjectsEXT(unboxed_device, pMetalObjectsInfo);
+                vkStream->unsetHandleMapping();
+                if (pMetalObjectsInfo) {
+                    transform_fromhost_VkExportMetalObjectsInfoEXT(
+                        m_state, (VkExportMetalObjectsInfoEXT*)(pMetalObjectsInfo));
+                }
+                marshal_VkExportMetalObjectsInfoEXT(
+                    vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkExportMetalObjectsInfoEXT*)(pMetalObjectsInfo));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkExportMetalObjectsEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pMetalObjectsInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+            case OP_vkGetDescriptorSetLayoutSizeEXT: {
+                android::base::beginTrace("vkGetDescriptorSetLayoutSizeEXT decode");
+                VkDevice device;
+                VkDescriptorSetLayout layout;
+                VkDeviceSize* pLayoutSizeInBytes;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDescriptorSetLayout*)&layout =
+                    (VkDescriptorSetLayout)unbox_VkDescriptorSetLayout(
+                        (VkDescriptorSetLayout)(*&cgen_var_1));
+                // Begin manual dispatchable handle unboxing for pLayoutSizeInBytes;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pLayoutSizeInBytes, sizeof(VkDeviceSize));
+                memcpy((VkDeviceSize*)pLayoutSizeInBytes, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkGetDescriptorSetLayoutSizeEXT 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)device, (unsigned long long)layout,
+                        (unsigned long long)pLayoutSizeInBytes);
+                }
+                vk->vkGetDescriptorSetLayoutSizeEXT(unboxed_device, layout, pLayoutSizeInBytes);
+                vkStream->unsetHandleMapping();
+                vkStream->write((VkDeviceSize*)pLayoutSizeInBytes, sizeof(VkDeviceSize));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetDescriptorSetLayoutSizeEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, layout,
+                        pLayoutSizeInBytes);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetDescriptorSetLayoutBindingOffsetEXT: {
+                android::base::beginTrace("vkGetDescriptorSetLayoutBindingOffsetEXT decode");
+                VkDevice device;
+                VkDescriptorSetLayout layout;
+                uint32_t binding;
+                VkDeviceSize* pOffset;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDescriptorSetLayout*)&layout =
+                    (VkDescriptorSetLayout)unbox_VkDescriptorSetLayout(
+                        (VkDescriptorSetLayout)(*&cgen_var_1));
+                memcpy((uint32_t*)&binding, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                // Begin manual dispatchable handle unboxing for pOffset;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pOffset, sizeof(VkDeviceSize));
+                memcpy((VkDeviceSize*)pOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetDescriptorSetLayoutBindingOffsetEXT 0x%llx "
+                            "0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)layout,
+                            (unsigned long long)binding, (unsigned long long)pOffset);
+                }
+                vk->vkGetDescriptorSetLayoutBindingOffsetEXT(unboxed_device, layout, binding,
+                                                             pOffset);
+                vkStream->unsetHandleMapping();
+                vkStream->write((VkDeviceSize*)pOffset, sizeof(VkDeviceSize));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetDescriptorSetLayoutBindingOffsetEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, layout, binding,
+                        pOffset);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetDescriptorEXT: {
+                android::base::beginTrace("vkGetDescriptorEXT decode");
+                VkDevice device;
+                const VkDescriptorGetInfoEXT* pDescriptorInfo;
+                size_t dataSize;
+                void* pDescriptor;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pDescriptorInfo, sizeof(const VkDescriptorGetInfoEXT));
+                reservedunmarshal_VkDescriptorGetInfoEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                         (VkDescriptorGetInfoEXT*)(pDescriptorInfo),
+                                                         readStreamPtrPtr);
+                memcpy((size_t*)&dataSize, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&dataSize);
+                *readStreamPtrPtr += 8;
+                // Begin manual dispatchable handle unboxing for pDescriptor;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pDescriptor, ((dataSize)) * sizeof(uint8_t));
+                memcpy((void*)pDescriptor, *readStreamPtrPtr, ((dataSize)) * sizeof(uint8_t));
+                *readStreamPtrPtr += ((dataSize)) * sizeof(uint8_t);
+                if (pDescriptorInfo) {
+                    transform_tohost_VkDescriptorGetInfoEXT(
+                        m_state, (VkDescriptorGetInfoEXT*)(pDescriptorInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(
+                        stderr, "stream %p: call vkGetDescriptorEXT 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)device, (unsigned long long)pDescriptorInfo,
+                        (unsigned long long)dataSize, (unsigned long long)pDescriptor);
+                }
+                vk->vkGetDescriptorEXT(unboxed_device, pDescriptorInfo, dataSize, pDescriptor);
+                vkStream->unsetHandleMapping();
+                vkStream->write((void*)pDescriptor, ((dataSize)) * sizeof(uint8_t));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetDescriptorEXT(snapshotTraceBegin, snapshotTraceBytes,
+                                                            &m_pool, device, pDescriptorInfo,
+                                                            dataSize, pDescriptor);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBindDescriptorBuffersEXT: {
+                android::base::beginTrace("vkCmdBindDescriptorBuffersEXT decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t bufferCount;
+                const VkDescriptorBufferBindingInfoEXT* pBindingInfos;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&bufferCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc(
+                    (void**)&pBindingInfos,
+                    ((bufferCount)) * sizeof(const VkDescriptorBufferBindingInfoEXT));
+                for (uint32_t i = 0; i < (uint32_t)((bufferCount)); ++i) {
+                    reservedunmarshal_VkDescriptorBufferBindingInfoEXT(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkDescriptorBufferBindingInfoEXT*)(pBindingInfos + i), readStreamPtrPtr);
+                }
+                if (pBindingInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((bufferCount)); ++i) {
+                        transform_tohost_VkDescriptorBufferBindingInfoEXT(
+                            m_state, (VkDescriptorBufferBindingInfoEXT*)(pBindingInfos + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdBindDescriptorBuffersEXT 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)bufferCount, (unsigned long long)pBindingInfos);
+                }
+                vk->vkCmdBindDescriptorBuffersEXT(unboxed_commandBuffer, bufferCount,
+                                                  pBindingInfos);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdBindDescriptorBuffersEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, bufferCount,
+                        pBindingInfos);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDescriptorBufferOffsetsEXT: {
+                android::base::beginTrace("vkCmdSetDescriptorBufferOffsetsEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkPipelineBindPoint pipelineBindPoint;
+                VkPipelineLayout layout;
+                uint32_t firstSet;
+                uint32_t setCount;
+                const uint32_t* pBufferIndices;
+                const VkDeviceSize* pOffsets;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
+                       sizeof(VkPipelineBindPoint));
+                *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkPipelineLayout*)&layout =
+                    (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_1));
+                memcpy((uint32_t*)&firstSet, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&setCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pBufferIndices, ((setCount)) * sizeof(const uint32_t));
+                memcpy((uint32_t*)pBufferIndices, *readStreamPtrPtr,
+                       ((setCount)) * sizeof(const uint32_t));
+                *readStreamPtrPtr += ((setCount)) * sizeof(const uint32_t);
+                vkReadStream->alloc((void**)&pOffsets, ((setCount)) * sizeof(const VkDeviceSize));
+                memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
+                       ((setCount)) * sizeof(const VkDeviceSize));
+                *readStreamPtrPtr += ((setCount)) * sizeof(const VkDeviceSize);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetDescriptorBufferOffsetsEXT 0x%llx 0x%llx "
+                            "0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)pipelineBindPoint, (unsigned long long)layout,
+                            (unsigned long long)firstSet, (unsigned long long)setCount,
+                            (unsigned long long)pBufferIndices, (unsigned long long)pOffsets);
+                }
+                vk->vkCmdSetDescriptorBufferOffsetsEXT(unboxed_commandBuffer, pipelineBindPoint,
+                                                       layout, firstSet, setCount, pBufferIndices,
+                                                       pOffsets);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetDescriptorBufferOffsetsEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBindDescriptorBufferEmbeddedSamplersEXT: {
+                android::base::beginTrace("vkCmdBindDescriptorBufferEmbeddedSamplersEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkPipelineBindPoint pipelineBindPoint;
+                VkPipelineLayout layout;
+                uint32_t set;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
+                       sizeof(VkPipelineBindPoint));
+                *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkPipelineLayout*)&layout =
+                    (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_1));
+                memcpy((uint32_t*)&set, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdBindDescriptorBufferEmbeddedSamplersEXT 0x%llx "
+                            "0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)pipelineBindPoint, (unsigned long long)layout,
+                            (unsigned long long)set);
+                }
+                vk->vkCmdBindDescriptorBufferEmbeddedSamplersEXT(unboxed_commandBuffer,
+                                                                 pipelineBindPoint, layout, set);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdBindDescriptorBufferEmbeddedSamplersEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        pipelineBindPoint, layout, set);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetBufferOpaqueCaptureDescriptorDataEXT: {
+                android::base::beginTrace("vkGetBufferOpaqueCaptureDescriptorDataEXT decode");
+                VkDevice device;
+                const VkBufferCaptureDescriptorDataInfoEXT* pInfo;
+                void* pData;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pInfo,
+                                    sizeof(const VkBufferCaptureDescriptorDataInfoEXT));
+                reservedunmarshal_VkBufferCaptureDescriptorDataInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkBufferCaptureDescriptorDataInfoEXT*)(pInfo), readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pData;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pData, sizeof(uint8_t));
+                memcpy((void*)pData, *readStreamPtrPtr, sizeof(uint8_t));
+                *readStreamPtrPtr += sizeof(uint8_t);
+                if (pInfo) {
+                    transform_tohost_VkBufferCaptureDescriptorDataInfoEXT(
+                        m_state, (VkBufferCaptureDescriptorDataInfoEXT*)(pInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetBufferOpaqueCaptureDescriptorDataEXT 0x%llx "
+                            "0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pInfo,
+                            (unsigned long long)pData);
+                }
+                VkResult vkGetBufferOpaqueCaptureDescriptorDataEXT_VkResult_return = (VkResult)0;
+                vkGetBufferOpaqueCaptureDescriptorDataEXT_VkResult_return =
+                    vk->vkGetBufferOpaqueCaptureDescriptorDataEXT(unboxed_device, pInfo, pData);
+                if ((vkGetBufferOpaqueCaptureDescriptorDataEXT_VkResult_return) ==
+                    VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(
+                    vkGetBufferOpaqueCaptureDescriptorDataEXT_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                vkStream->write((void*)pData, sizeof(uint8_t));
+                vkStream->write(&vkGetBufferOpaqueCaptureDescriptorDataEXT_VkResult_return,
+                                sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetBufferOpaqueCaptureDescriptorDataEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkGetBufferOpaqueCaptureDescriptorDataEXT_VkResult_return, device, pInfo,
+                        pData);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetImageOpaqueCaptureDescriptorDataEXT: {
+                android::base::beginTrace("vkGetImageOpaqueCaptureDescriptorDataEXT decode");
+                VkDevice device;
+                const VkImageCaptureDescriptorDataInfoEXT* pInfo;
+                void* pData;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pInfo,
+                                    sizeof(const VkImageCaptureDescriptorDataInfoEXT));
+                reservedunmarshal_VkImageCaptureDescriptorDataInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkImageCaptureDescriptorDataInfoEXT*)(pInfo), readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pData;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pData, sizeof(uint8_t));
+                memcpy((void*)pData, *readStreamPtrPtr, sizeof(uint8_t));
+                *readStreamPtrPtr += sizeof(uint8_t);
+                if (pInfo) {
+                    transform_tohost_VkImageCaptureDescriptorDataInfoEXT(
+                        m_state, (VkImageCaptureDescriptorDataInfoEXT*)(pInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetImageOpaqueCaptureDescriptorDataEXT 0x%llx "
+                            "0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pInfo,
+                            (unsigned long long)pData);
+                }
+                VkResult vkGetImageOpaqueCaptureDescriptorDataEXT_VkResult_return = (VkResult)0;
+                vkGetImageOpaqueCaptureDescriptorDataEXT_VkResult_return =
+                    vk->vkGetImageOpaqueCaptureDescriptorDataEXT(unboxed_device, pInfo, pData);
+                if ((vkGetImageOpaqueCaptureDescriptorDataEXT_VkResult_return) ==
+                    VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(
+                    vkGetImageOpaqueCaptureDescriptorDataEXT_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                vkStream->write((void*)pData, sizeof(uint8_t));
+                vkStream->write(&vkGetImageOpaqueCaptureDescriptorDataEXT_VkResult_return,
+                                sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetImageOpaqueCaptureDescriptorDataEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkGetImageOpaqueCaptureDescriptorDataEXT_VkResult_return, device, pInfo,
+                        pData);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetImageViewOpaqueCaptureDescriptorDataEXT: {
+                android::base::beginTrace("vkGetImageViewOpaqueCaptureDescriptorDataEXT decode");
+                VkDevice device;
+                const VkImageViewCaptureDescriptorDataInfoEXT* pInfo;
+                void* pData;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pInfo,
+                                    sizeof(const VkImageViewCaptureDescriptorDataInfoEXT));
+                reservedunmarshal_VkImageViewCaptureDescriptorDataInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkImageViewCaptureDescriptorDataInfoEXT*)(pInfo), readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pData;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pData, sizeof(uint8_t));
+                memcpy((void*)pData, *readStreamPtrPtr, sizeof(uint8_t));
+                *readStreamPtrPtr += sizeof(uint8_t);
+                if (pInfo) {
+                    transform_tohost_VkImageViewCaptureDescriptorDataInfoEXT(
+                        m_state, (VkImageViewCaptureDescriptorDataInfoEXT*)(pInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetImageViewOpaqueCaptureDescriptorDataEXT 0x%llx "
+                            "0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pInfo,
+                            (unsigned long long)pData);
+                }
+                VkResult vkGetImageViewOpaqueCaptureDescriptorDataEXT_VkResult_return = (VkResult)0;
+                vkGetImageViewOpaqueCaptureDescriptorDataEXT_VkResult_return =
+                    vk->vkGetImageViewOpaqueCaptureDescriptorDataEXT(unboxed_device, pInfo, pData);
+                if ((vkGetImageViewOpaqueCaptureDescriptorDataEXT_VkResult_return) ==
+                    VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(
+                    vkGetImageViewOpaqueCaptureDescriptorDataEXT_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                vkStream->write((void*)pData, sizeof(uint8_t));
+                vkStream->write(&vkGetImageViewOpaqueCaptureDescriptorDataEXT_VkResult_return,
+                                sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetImageViewOpaqueCaptureDescriptorDataEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkGetImageViewOpaqueCaptureDescriptorDataEXT_VkResult_return, device, pInfo,
+                        pData);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetSamplerOpaqueCaptureDescriptorDataEXT: {
+                android::base::beginTrace("vkGetSamplerOpaqueCaptureDescriptorDataEXT decode");
+                VkDevice device;
+                const VkSamplerCaptureDescriptorDataInfoEXT* pInfo;
+                void* pData;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pInfo,
+                                    sizeof(const VkSamplerCaptureDescriptorDataInfoEXT));
+                reservedunmarshal_VkSamplerCaptureDescriptorDataInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkSamplerCaptureDescriptorDataInfoEXT*)(pInfo), readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pData;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pData, sizeof(uint8_t));
+                memcpy((void*)pData, *readStreamPtrPtr, sizeof(uint8_t));
+                *readStreamPtrPtr += sizeof(uint8_t);
+                if (pInfo) {
+                    transform_tohost_VkSamplerCaptureDescriptorDataInfoEXT(
+                        m_state, (VkSamplerCaptureDescriptorDataInfoEXT*)(pInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetSamplerOpaqueCaptureDescriptorDataEXT 0x%llx "
+                            "0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pInfo,
+                            (unsigned long long)pData);
+                }
+                VkResult vkGetSamplerOpaqueCaptureDescriptorDataEXT_VkResult_return = (VkResult)0;
+                vkGetSamplerOpaqueCaptureDescriptorDataEXT_VkResult_return =
+                    vk->vkGetSamplerOpaqueCaptureDescriptorDataEXT(unboxed_device, pInfo, pData);
+                if ((vkGetSamplerOpaqueCaptureDescriptorDataEXT_VkResult_return) ==
+                    VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(
+                    vkGetSamplerOpaqueCaptureDescriptorDataEXT_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                vkStream->write((void*)pData, sizeof(uint8_t));
+                vkStream->write(&vkGetSamplerOpaqueCaptureDescriptorDataEXT_VkResult_return,
+                                sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetSamplerOpaqueCaptureDescriptorDataEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkGetSamplerOpaqueCaptureDescriptorDataEXT_VkResult_return, device, pInfo,
+                        pData);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT: {
+                android::base::beginTrace(
+                    "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT decode");
+                VkDevice device;
+                const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo;
+                void* pData;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc(
+                    (void**)&pInfo,
+                    sizeof(const VkAccelerationStructureCaptureDescriptorDataInfoEXT));
+                reservedunmarshal_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkAccelerationStructureCaptureDescriptorDataInfoEXT*)(pInfo),
+                    readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pData;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pData, sizeof(uint8_t));
+                memcpy((void*)pData, *readStreamPtrPtr, sizeof(uint8_t));
+                *readStreamPtrPtr += sizeof(uint8_t);
+                if (pInfo) {
+                    transform_tohost_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+                        m_state, (VkAccelerationStructureCaptureDescriptorDataInfoEXT*)(pInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT "
+                        "0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)device, (unsigned long long)pInfo,
+                        (unsigned long long)pData);
+                }
+                VkResult vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_VkResult_return =
+                    (VkResult)0;
+                vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_VkResult_return =
+                    vk->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(unboxed_device,
+                                                                                 pInfo, pData);
+                if ((vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_VkResult_return) ==
+                    VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(
+                    vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_VkResult_return,
+                    opcode, context);
+                vkStream->unsetHandleMapping();
+                vkStream->write((void*)pData, sizeof(uint8_t));
+                vkStream->write(
+                    &vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_VkResult_return,
+                    sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT_VkResult_return,
+                        device, pInfo, pData);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
             case OP_vkCmdSetFragmentShadingRateEnumNV: {
                 android::base::beginTrace("vkCmdSetFragmentShadingRateEnumNV decode");
@@ -29998,8 +32717,168 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
 #endif
 #ifdef VK_EXT_image_robustness
 #endif
+#ifdef VK_EXT_image_compression_control
+            case OP_vkGetImageSubresourceLayout2EXT: {
+                android::base::beginTrace("vkGetImageSubresourceLayout2EXT decode");
+                VkDevice device;
+                VkImage image;
+                const VkImageSubresource2EXT* pSubresource;
+                VkSubresourceLayout2EXT* pLayout;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkImage*)&image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
+                vkReadStream->alloc((void**)&pSubresource, sizeof(const VkImageSubresource2EXT));
+                reservedunmarshal_VkImageSubresource2EXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                         (VkImageSubresource2EXT*)(pSubresource),
+                                                         readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pLayout;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pLayout, sizeof(VkSubresourceLayout2EXT));
+                reservedunmarshal_VkSubresourceLayout2EXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                          (VkSubresourceLayout2EXT*)(pLayout),
+                                                          readStreamPtrPtr);
+                if (pSubresource) {
+                    transform_tohost_VkImageSubresource2EXT(
+                        m_state, (VkImageSubresource2EXT*)(pSubresource));
+                }
+                if (pLayout) {
+                    transform_tohost_VkSubresourceLayout2EXT(m_state,
+                                                             (VkSubresourceLayout2EXT*)(pLayout));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetImageSubresourceLayout2EXT 0x%llx 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)image,
+                            (unsigned long long)pSubresource, (unsigned long long)pLayout);
+                }
+                vk->vkGetImageSubresourceLayout2EXT(unboxed_device, image, pSubresource, pLayout);
+                vkStream->unsetHandleMapping();
+                if (pLayout) {
+                    transform_fromhost_VkSubresourceLayout2EXT(m_state,
+                                                               (VkSubresourceLayout2EXT*)(pLayout));
+                }
+                marshal_VkSubresourceLayout2EXT(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                (VkSubresourceLayout2EXT*)(pLayout));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetImageSubresourceLayout2EXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, image,
+                        pSubresource, pLayout);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+#endif
 #ifdef VK_EXT_4444_formats
 #endif
+#ifdef VK_EXT_device_fault
+            case OP_vkGetDeviceFaultInfoEXT: {
+                android::base::beginTrace("vkGetDeviceFaultInfoEXT decode");
+                VkDevice device;
+                VkDeviceFaultCountsEXT* pFaultCounts;
+                VkDeviceFaultInfoEXT* pFaultInfo;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                // Begin manual dispatchable handle unboxing for pFaultCounts;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pFaultCounts, sizeof(VkDeviceFaultCountsEXT));
+                reservedunmarshal_VkDeviceFaultCountsEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                         (VkDeviceFaultCountsEXT*)(pFaultCounts),
+                                                         readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pFaultInfo;
+                vkReadStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                memcpy((VkDeviceFaultInfoEXT**)&pFaultInfo, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pFaultInfo);
+                *readStreamPtrPtr += 8;
+                if (pFaultInfo) {
+                    vkReadStream->alloc((void**)&pFaultInfo, sizeof(VkDeviceFaultInfoEXT));
+                    reservedunmarshal_VkDeviceFaultInfoEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                           (VkDeviceFaultInfoEXT*)(pFaultInfo),
+                                                           readStreamPtrPtr);
+                }
+                if (pFaultCounts) {
+                    transform_tohost_VkDeviceFaultCountsEXT(
+                        m_state, (VkDeviceFaultCountsEXT*)(pFaultCounts));
+                }
+                if (pFaultInfo) {
+                    transform_tohost_VkDeviceFaultInfoEXT(m_state,
+                                                          (VkDeviceFaultInfoEXT*)(pFaultInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetDeviceFaultInfoEXT 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pFaultCounts,
+                            (unsigned long long)pFaultInfo);
+                }
+                VkResult vkGetDeviceFaultInfoEXT_VkResult_return = (VkResult)0;
+                vkGetDeviceFaultInfoEXT_VkResult_return =
+                    vk->vkGetDeviceFaultInfoEXT(unboxed_device, pFaultCounts, pFaultInfo);
+                if ((vkGetDeviceFaultInfoEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkGetDeviceFaultInfoEXT_VkResult_return, opcode,
+                                             context);
+                vkStream->unsetHandleMapping();
+                if (pFaultCounts) {
+                    transform_fromhost_VkDeviceFaultCountsEXT(
+                        m_state, (VkDeviceFaultCountsEXT*)(pFaultCounts));
+                }
+                marshal_VkDeviceFaultCountsEXT(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                               (VkDeviceFaultCountsEXT*)(pFaultCounts));
+                if (pFaultInfo) {
+                    transform_fromhost_VkDeviceFaultInfoEXT(m_state,
+                                                            (VkDeviceFaultInfoEXT*)(pFaultInfo));
+                }
+                // WARNING PTR CHECK
+                uint64_t cgen_var_2 = (uint64_t)(uintptr_t)pFaultInfo;
+                vkStream->putBe64(cgen_var_2);
+                if (pFaultInfo) {
+                    marshal_VkDeviceFaultInfoEXT(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                 (VkDeviceFaultInfoEXT*)(pFaultInfo));
+                }
+                vkStream->write(&vkGetDeviceFaultInfoEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetDeviceFaultInfoEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkGetDeviceFaultInfoEXT_VkResult_return, device, pFaultCounts, pFaultInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 #endif
 #ifdef VK_NV_acquire_winrt_display
@@ -30334,6 +33213,10 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
 #endif
 #ifdef VK_EXT_physical_device_drm
 #endif
+#ifdef VK_EXT_device_address_binding_report
+#endif
+#ifdef VK_EXT_depth_clip_control
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 #endif
 #ifdef VK_FUCHSIA_external_memory
@@ -31129,6 +34012,89 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 break;
             }
 #endif
+#ifdef VK_EXT_pipeline_properties
+            case OP_vkGetPipelinePropertiesEXT: {
+                android::base::beginTrace("vkGetPipelinePropertiesEXT decode");
+                VkDevice device;
+                const VkPipelineInfoEXT* pPipelineInfo;
+                VkBaseOutStructure* pPipelineProperties;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pPipelineInfo, sizeof(const VkPipelineInfoEXT));
+                reservedunmarshal_VkPipelineInfoEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                    (VkPipelineInfoEXT*)(pPipelineInfo),
+                                                    readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pPipelineProperties;
+                vkReadStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                memcpy((VkBaseOutStructure**)&pPipelineProperties, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pPipelineProperties);
+                *readStreamPtrPtr += 8;
+                if (pPipelineProperties) {
+                    vkReadStream->alloc((void**)&pPipelineProperties, sizeof(VkBaseOutStructure));
+                    reservedunmarshal_VkBaseOutStructure(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                         (VkBaseOutStructure*)(pPipelineProperties),
+                                                         readStreamPtrPtr);
+                }
+                if (pPipelineInfo) {
+                    transform_tohost_VkPipelineInfoEXT(m_state,
+                                                       (VkPipelineInfoEXT*)(pPipelineInfo));
+                }
+                if (pPipelineProperties) {
+                    transform_tohost_VkBaseOutStructure(m_state,
+                                                        (VkBaseOutStructure*)(pPipelineProperties));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetPipelinePropertiesEXT 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pPipelineInfo,
+                            (unsigned long long)pPipelineProperties);
+                }
+                VkResult vkGetPipelinePropertiesEXT_VkResult_return = (VkResult)0;
+                vkGetPipelinePropertiesEXT_VkResult_return = vk->vkGetPipelinePropertiesEXT(
+                    unboxed_device, pPipelineInfo, pPipelineProperties);
+                if ((vkGetPipelinePropertiesEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkGetPipelinePropertiesEXT_VkResult_return, opcode,
+                                             context);
+                vkStream->unsetHandleMapping();
+                if (pPipelineProperties) {
+                    transform_fromhost_VkBaseOutStructure(
+                        m_state, (VkBaseOutStructure*)(pPipelineProperties));
+                }
+                // WARNING PTR CHECK
+                uint64_t cgen_var_2 = (uint64_t)(uintptr_t)pPipelineProperties;
+                vkStream->putBe64(cgen_var_2);
+                if (pPipelineProperties) {
+                    marshal_VkBaseOutStructure(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                               (VkBaseOutStructure*)(pPipelineProperties));
+                }
+                vkStream->write(&vkGetPipelinePropertiesEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetPipelinePropertiesEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkGetPipelinePropertiesEXT_VkResult_return, device, pPipelineInfo,
+                        pPipelineProperties);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
             case OP_vkCmdSetPatchControlPointsEXT: {
                 android::base::beginTrace("vkCmdSetPatchControlPointsEXT decode");
@@ -31496,6 +34462,8 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 break;
             }
 #endif
+#ifdef VK_EXT_primitives_generated_query
+#endif
 #ifdef VK_GOOGLE_gfxstream
             case OP_vkMapMemoryIntoAddressSpaceGOOGLE: {
                 android::base::beginTrace("vkMapMemoryIntoAddressSpaceGOOGLE decode");
@@ -32894,9 +35862,191 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 android::base::endTrace();
                 break;
             }
+            case OP_vkUpdateDescriptorSetWithTemplateSized2GOOGLE: {
+                android::base::beginTrace("vkUpdateDescriptorSetWithTemplateSized2GOOGLE decode");
+                VkDevice device;
+                VkDescriptorSet descriptorSet;
+                VkDescriptorUpdateTemplate descriptorUpdateTemplate;
+                uint32_t imageInfoCount;
+                uint32_t bufferInfoCount;
+                uint32_t bufferViewCount;
+                uint32_t inlineUniformBlockCount;
+                const uint32_t* pImageInfoEntryIndices;
+                const uint32_t* pBufferInfoEntryIndices;
+                const uint32_t* pBufferViewEntryIndices;
+                const VkDescriptorImageInfo* pImageInfos;
+                const VkDescriptorBufferInfo* pBufferInfos;
+                const VkBufferView* pBufferViews;
+                const uint8_t* pInlineUniformBlockData;
+                // Begin global wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDescriptorSet*)&descriptorSet =
+                    (VkDescriptorSet)unbox_VkDescriptorSet((VkDescriptorSet)(*&cgen_var_1));
+                uint64_t cgen_var_2;
+                memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDescriptorUpdateTemplate*)&descriptorUpdateTemplate =
+                    (VkDescriptorUpdateTemplate)unbox_VkDescriptorUpdateTemplate(
+                        (VkDescriptorUpdateTemplate)(*&cgen_var_2));
+                memcpy((uint32_t*)&imageInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&bufferInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&bufferViewCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&inlineUniformBlockCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                // WARNING PTR CHECK
+                memcpy((uint32_t**)&pImageInfoEntryIndices, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pImageInfoEntryIndices);
+                *readStreamPtrPtr += 8;
+                if (pImageInfoEntryIndices) {
+                    vkReadStream->alloc((void**)&pImageInfoEntryIndices,
+                                        ((imageInfoCount)) * sizeof(const uint32_t));
+                    memcpy((uint32_t*)pImageInfoEntryIndices, *readStreamPtrPtr,
+                           ((imageInfoCount)) * sizeof(const uint32_t));
+                    *readStreamPtrPtr += ((imageInfoCount)) * sizeof(const uint32_t);
+                }
+                // WARNING PTR CHECK
+                memcpy((uint32_t**)&pBufferInfoEntryIndices, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pBufferInfoEntryIndices);
+                *readStreamPtrPtr += 8;
+                if (pBufferInfoEntryIndices) {
+                    vkReadStream->alloc((void**)&pBufferInfoEntryIndices,
+                                        ((bufferInfoCount)) * sizeof(const uint32_t));
+                    memcpy((uint32_t*)pBufferInfoEntryIndices, *readStreamPtrPtr,
+                           ((bufferInfoCount)) * sizeof(const uint32_t));
+                    *readStreamPtrPtr += ((bufferInfoCount)) * sizeof(const uint32_t);
+                }
+                // WARNING PTR CHECK
+                memcpy((uint32_t**)&pBufferViewEntryIndices, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pBufferViewEntryIndices);
+                *readStreamPtrPtr += 8;
+                if (pBufferViewEntryIndices) {
+                    vkReadStream->alloc((void**)&pBufferViewEntryIndices,
+                                        ((bufferViewCount)) * sizeof(const uint32_t));
+                    memcpy((uint32_t*)pBufferViewEntryIndices, *readStreamPtrPtr,
+                           ((bufferViewCount)) * sizeof(const uint32_t));
+                    *readStreamPtrPtr += ((bufferViewCount)) * sizeof(const uint32_t);
+                }
+                // WARNING PTR CHECK
+                memcpy((VkDescriptorImageInfo**)&pImageInfos, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pImageInfos);
+                *readStreamPtrPtr += 8;
+                if (pImageInfos) {
+                    vkReadStream->alloc((void**)&pImageInfos,
+                                        ((imageInfoCount)) * sizeof(const VkDescriptorImageInfo));
+                    for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i) {
+                        reservedunmarshal_VkDescriptorImageInfo(
+                            vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                            (VkDescriptorImageInfo*)(pImageInfos + i), readStreamPtrPtr);
+                    }
+                }
+                // WARNING PTR CHECK
+                memcpy((VkDescriptorBufferInfo**)&pBufferInfos, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pBufferInfos);
+                *readStreamPtrPtr += 8;
+                if (pBufferInfos) {
+                    vkReadStream->alloc((void**)&pBufferInfos,
+                                        ((bufferInfoCount)) * sizeof(const VkDescriptorBufferInfo));
+                    for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i) {
+                        reservedunmarshal_VkDescriptorBufferInfo(
+                            vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                            (VkDescriptorBufferInfo*)(pBufferInfos + i), readStreamPtrPtr);
+                    }
+                }
+                // WARNING PTR CHECK
+                memcpy((VkBufferView**)&pBufferViews, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pBufferViews);
+                *readStreamPtrPtr += 8;
+                if (pBufferViews) {
+                    vkReadStream->alloc((void**)&pBufferViews,
+                                        ((bufferViewCount)) * sizeof(const VkBufferView));
+                    if (((bufferViewCount))) {
+                        uint8_t* cgen_var_8_0_ptr = (uint8_t*)(*readStreamPtrPtr);
+                        *readStreamPtrPtr += 8 * ((bufferViewCount));
+                        for (uint32_t k = 0; k < ((bufferViewCount)); ++k) {
+                            uint64_t tmpval;
+                            memcpy(&tmpval, cgen_var_8_0_ptr + k * 8, sizeof(uint64_t));
+                            *(((VkBufferView*)pBufferViews) + k) =
+                                (VkBufferView)unbox_VkBufferView((VkBufferView)tmpval);
+                        }
+                    }
+                }
+                // WARNING PTR CHECK
+                memcpy((uint8_t**)&pInlineUniformBlockData, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pInlineUniformBlockData);
+                *readStreamPtrPtr += 8;
+                if (pInlineUniformBlockData) {
+                    vkReadStream->alloc((void**)&pInlineUniformBlockData,
+                                        ((inlineUniformBlockCount)) * sizeof(const uint8_t));
+                    memcpy((uint8_t*)pInlineUniformBlockData, *readStreamPtrPtr,
+                           ((inlineUniformBlockCount)) * sizeof(const uint8_t));
+                    *readStreamPtrPtr += ((inlineUniformBlockCount)) * sizeof(const uint8_t);
+                }
+                if (pImageInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((imageInfoCount)); ++i) {
+                        transform_tohost_VkDescriptorImageInfo(
+                            m_state, (VkDescriptorImageInfo*)(pImageInfos + i));
+                    }
+                }
+                if (pBufferInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((bufferInfoCount)); ++i) {
+                        transform_tohost_VkDescriptorBufferInfo(
+                            m_state, (VkDescriptorBufferInfo*)(pBufferInfos + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkUpdateDescriptorSetWithTemplateSized2GOOGLE 0x%llx "
+                            "0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx "
+                            "0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)descriptorSet,
+                            (unsigned long long)descriptorUpdateTemplate,
+                            (unsigned long long)imageInfoCount, (unsigned long long)bufferInfoCount,
+                            (unsigned long long)bufferViewCount,
+                            (unsigned long long)inlineUniformBlockCount,
+                            (unsigned long long)pImageInfoEntryIndices,
+                            (unsigned long long)pBufferInfoEntryIndices,
+                            (unsigned long long)pBufferViewEntryIndices,
+                            (unsigned long long)pImageInfos, (unsigned long long)pBufferInfos,
+                            (unsigned long long)pBufferViews,
+                            (unsigned long long)pInlineUniformBlockData);
+                }
+                m_state->on_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+                    &m_pool, device, descriptorSet, descriptorUpdateTemplate, imageInfoCount,
+                    bufferInfoCount, bufferViewCount, inlineUniformBlockCount,
+                    pImageInfoEntryIndices, pBufferInfoEntryIndices, pBufferViewEntryIndices,
+                    pImageInfos, pBufferInfos, pBufferViews, pInlineUniformBlockData);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, descriptorSet,
+                        descriptorUpdateTemplate, imageInfoCount, bufferInfoCount, bufferViewCount,
+                        inlineUniformBlockCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
+                        pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews,
+                        pInlineUniformBlockData);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
 #endif
 #ifdef VK_EXT_global_priority_query
 #endif
+#ifdef VK_EXT_image_view_min_lod
+#endif
 #ifdef VK_EXT_multi_draw
             case OP_vkCmdDrawMultiEXT: {
                 android::base::beginTrace("vkCmdDrawMultiEXT decode");
@@ -33049,8 +36199,882 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 break;
             }
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+#endif
+#ifdef VK_EXT_shader_tile_image
+#endif
+#ifdef VK_EXT_opacity_micromap
+            case OP_vkCreateMicromapEXT: {
+                android::base::beginTrace("vkCreateMicromapEXT decode");
+                VkDevice device;
+                const VkMicromapCreateInfoEXT* pCreateInfo;
+                const VkAllocationCallbacks* pAllocator;
+                VkMicromapEXT* pMicromap;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkMicromapCreateInfoEXT));
+                reservedunmarshal_VkMicromapCreateInfoEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                          (VkMicromapCreateInfoEXT*)(pCreateInfo),
+                                                          readStreamPtrPtr);
+                // WARNING PTR CHECK
+                memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pAllocator);
+                *readStreamPtrPtr += 8;
+                if (pAllocator) {
+                    vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
+                    reservedunmarshal_VkAllocationCallbacks(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
+                }
+                // Begin manual dispatchable handle unboxing for pMicromap;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pMicromap, sizeof(VkMicromapEXT));
+                memcpy((VkMicromapEXT*)&(*pMicromap), (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&(*pMicromap));
+                *readStreamPtrPtr += 8;
+                if (pCreateInfo) {
+                    transform_tohost_VkMicromapCreateInfoEXT(
+                        m_state, (VkMicromapCreateInfoEXT*)(pCreateInfo));
+                }
+                if (pAllocator) {
+                    transform_tohost_VkAllocationCallbacks(m_state,
+                                                           (VkAllocationCallbacks*)(pAllocator));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCreateMicromapEXT 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
+                            (unsigned long long)pAllocator, (unsigned long long)pMicromap);
+                }
+                VkResult vkCreateMicromapEXT_VkResult_return = (VkResult)0;
+                vkCreateMicromapEXT_VkResult_return =
+                    vk->vkCreateMicromapEXT(unboxed_device, pCreateInfo, pAllocator, pMicromap);
+                if ((vkCreateMicromapEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkCreateMicromapEXT_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                uint64_t cgen_var_3 = (uint64_t)(*pMicromap);
+                vkStream->putBe64(cgen_var_3);
+                vkStream->write(&vkCreateMicromapEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCreateMicromapEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkCreateMicromapEXT_VkResult_return, device, pCreateInfo, pAllocator,
+                        pMicromap);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkDestroyMicromapEXT: {
+                android::base::beginTrace("vkDestroyMicromapEXT decode");
+                VkDevice device;
+                VkMicromapEXT micromap;
+                const VkAllocationCallbacks* pAllocator;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((VkMicromapEXT*)&micromap, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&micromap);
+                *readStreamPtrPtr += 8;
+                // WARNING PTR CHECK
+                memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pAllocator);
+                *readStreamPtrPtr += 8;
+                if (pAllocator) {
+                    vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
+                    reservedunmarshal_VkAllocationCallbacks(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
+                }
+                if (pAllocator) {
+                    transform_tohost_VkAllocationCallbacks(m_state,
+                                                           (VkAllocationCallbacks*)(pAllocator));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkDestroyMicromapEXT 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)micromap,
+                            (unsigned long long)pAllocator);
+                }
+                vk->vkDestroyMicromapEXT(unboxed_device, micromap, pAllocator);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkDestroyMicromapEXT(snapshotTraceBegin,
+                                                              snapshotTraceBytes, &m_pool, device,
+                                                              micromap, pAllocator);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBuildMicromapsEXT: {
+                android::base::beginTrace("vkCmdBuildMicromapsEXT decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t infoCount;
+                const VkMicromapBuildInfoEXT* pInfos;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&infoCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pInfos,
+                                    ((infoCount)) * sizeof(const VkMicromapBuildInfoEXT));
+                for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+                    reservedunmarshal_VkMicromapBuildInfoEXT(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkMicromapBuildInfoEXT*)(pInfos + i), readStreamPtrPtr);
+                }
+                if (pInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+                        transform_tohost_VkMicromapBuildInfoEXT(
+                            m_state, (VkMicromapBuildInfoEXT*)(pInfos + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdBuildMicromapsEXT 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)infoCount, (unsigned long long)pInfos);
+                }
+                vk->vkCmdBuildMicromapsEXT(unboxed_commandBuffer, infoCount, pInfos);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdBuildMicromapsEXT(snapshotTraceBegin,
+                                                                snapshotTraceBytes, &m_pool,
+                                                                commandBuffer, infoCount, pInfos);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkBuildMicromapsEXT: {
+                android::base::beginTrace("vkBuildMicromapsEXT decode");
+                VkDevice device;
+                VkDeferredOperationKHR deferredOperation;
+                uint32_t infoCount;
+                const VkMicromapBuildInfoEXT* pInfos;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((VkDeferredOperationKHR*)&deferredOperation, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&deferredOperation);
+                *readStreamPtrPtr += 8;
+                memcpy((uint32_t*)&infoCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pInfos,
+                                    ((infoCount)) * sizeof(const VkMicromapBuildInfoEXT));
+                for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+                    reservedunmarshal_VkMicromapBuildInfoEXT(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkMicromapBuildInfoEXT*)(pInfos + i), readStreamPtrPtr);
+                }
+                if (pInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+                        transform_tohost_VkMicromapBuildInfoEXT(
+                            m_state, (VkMicromapBuildInfoEXT*)(pInfos + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkBuildMicromapsEXT 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device,
+                            (unsigned long long)deferredOperation, (unsigned long long)infoCount,
+                            (unsigned long long)pInfos);
+                }
+                VkResult vkBuildMicromapsEXT_VkResult_return = (VkResult)0;
+                vkBuildMicromapsEXT_VkResult_return =
+                    vk->vkBuildMicromapsEXT(unboxed_device, deferredOperation, infoCount, pInfos);
+                if ((vkBuildMicromapsEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkBuildMicromapsEXT_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                vkStream->write(&vkBuildMicromapsEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkBuildMicromapsEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkBuildMicromapsEXT_VkResult_return, device, deferredOperation, infoCount,
+                        pInfos);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCopyMicromapEXT: {
+                android::base::beginTrace("vkCopyMicromapEXT decode");
+                VkDevice device;
+                VkDeferredOperationKHR deferredOperation;
+                const VkCopyMicromapInfoEXT* pInfo;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((VkDeferredOperationKHR*)&deferredOperation, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&deferredOperation);
+                *readStreamPtrPtr += 8;
+                vkReadStream->alloc((void**)&pInfo, sizeof(const VkCopyMicromapInfoEXT));
+                reservedunmarshal_VkCopyMicromapInfoEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                        (VkCopyMicromapInfoEXT*)(pInfo),
+                                                        readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyMicromapInfoEXT(m_state,
+                                                           (VkCopyMicromapInfoEXT*)(pInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCopyMicromapEXT 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device,
+                            (unsigned long long)deferredOperation, (unsigned long long)pInfo);
+                }
+                VkResult vkCopyMicromapEXT_VkResult_return = (VkResult)0;
+                vkCopyMicromapEXT_VkResult_return =
+                    vk->vkCopyMicromapEXT(unboxed_device, deferredOperation, pInfo);
+                if ((vkCopyMicromapEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkCopyMicromapEXT_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                vkStream->write(&vkCopyMicromapEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCopyMicromapEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkCopyMicromapEXT_VkResult_return, device, deferredOperation, pInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCopyMicromapToMemoryEXT: {
+                android::base::beginTrace("vkCopyMicromapToMemoryEXT decode");
+                VkDevice device;
+                VkDeferredOperationKHR deferredOperation;
+                const VkCopyMicromapToMemoryInfoEXT* pInfo;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((VkDeferredOperationKHR*)&deferredOperation, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&deferredOperation);
+                *readStreamPtrPtr += 8;
+                vkReadStream->alloc((void**)&pInfo, sizeof(const VkCopyMicromapToMemoryInfoEXT));
+                reservedunmarshal_VkCopyMicromapToMemoryInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyMicromapToMemoryInfoEXT*)(pInfo), readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyMicromapToMemoryInfoEXT(
+                        m_state, (VkCopyMicromapToMemoryInfoEXT*)(pInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCopyMicromapToMemoryEXT 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device,
+                            (unsigned long long)deferredOperation, (unsigned long long)pInfo);
+                }
+                VkResult vkCopyMicromapToMemoryEXT_VkResult_return = (VkResult)0;
+                vkCopyMicromapToMemoryEXT_VkResult_return =
+                    vk->vkCopyMicromapToMemoryEXT(unboxed_device, deferredOperation, pInfo);
+                if ((vkCopyMicromapToMemoryEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkCopyMicromapToMemoryEXT_VkResult_return, opcode,
+                                             context);
+                vkStream->unsetHandleMapping();
+                vkStream->write(&vkCopyMicromapToMemoryEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCopyMicromapToMemoryEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkCopyMicromapToMemoryEXT_VkResult_return, device, deferredOperation,
+                        pInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCopyMemoryToMicromapEXT: {
+                android::base::beginTrace("vkCopyMemoryToMicromapEXT decode");
+                VkDevice device;
+                VkDeferredOperationKHR deferredOperation;
+                const VkCopyMemoryToMicromapInfoEXT* pInfo;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((VkDeferredOperationKHR*)&deferredOperation, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&deferredOperation);
+                *readStreamPtrPtr += 8;
+                vkReadStream->alloc((void**)&pInfo, sizeof(const VkCopyMemoryToMicromapInfoEXT));
+                reservedunmarshal_VkCopyMemoryToMicromapInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyMemoryToMicromapInfoEXT*)(pInfo), readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyMemoryToMicromapInfoEXT(
+                        m_state, (VkCopyMemoryToMicromapInfoEXT*)(pInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCopyMemoryToMicromapEXT 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device,
+                            (unsigned long long)deferredOperation, (unsigned long long)pInfo);
+                }
+                VkResult vkCopyMemoryToMicromapEXT_VkResult_return = (VkResult)0;
+                vkCopyMemoryToMicromapEXT_VkResult_return =
+                    vk->vkCopyMemoryToMicromapEXT(unboxed_device, deferredOperation, pInfo);
+                if ((vkCopyMemoryToMicromapEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkCopyMemoryToMicromapEXT_VkResult_return, opcode,
+                                             context);
+                vkStream->unsetHandleMapping();
+                vkStream->write(&vkCopyMemoryToMicromapEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCopyMemoryToMicromapEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkCopyMemoryToMicromapEXT_VkResult_return, device, deferredOperation,
+                        pInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkWriteMicromapsPropertiesEXT: {
+                android::base::beginTrace("vkWriteMicromapsPropertiesEXT decode");
+                VkDevice device;
+                uint32_t micromapCount;
+                const VkMicromapEXT* pMicromaps;
+                VkQueryType queryType;
+                size_t dataSize;
+                void* pData;
+                size_t stride;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((uint32_t*)&micromapCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pMicromaps,
+                                    ((micromapCount)) * sizeof(const VkMicromapEXT));
+                for (uint32_t i = 0; i < (uint32_t)((micromapCount)); ++i) {
+                    memcpy((VkMicromapEXT*)&pMicromaps[i], (*readStreamPtrPtr), 8);
+                    android::base::Stream::fromBe64((uint8_t*)&pMicromaps[i]);
+                    *readStreamPtrPtr += 8;
+                }
+                memcpy((VkQueryType*)&queryType, *readStreamPtrPtr, sizeof(VkQueryType));
+                *readStreamPtrPtr += sizeof(VkQueryType);
+                memcpy((size_t*)&dataSize, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&dataSize);
+                *readStreamPtrPtr += 8;
+                // Begin manual dispatchable handle unboxing for pData;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pData, ((dataSize)) * sizeof(uint8_t));
+                memcpy((void*)pData, *readStreamPtrPtr, ((dataSize)) * sizeof(uint8_t));
+                *readStreamPtrPtr += ((dataSize)) * sizeof(uint8_t);
+                memcpy((size_t*)&stride, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&stride);
+                *readStreamPtrPtr += 8;
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkWriteMicromapsPropertiesEXT 0x%llx 0x%llx 0x%llx "
+                            "0x%llx 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)micromapCount,
+                            (unsigned long long)pMicromaps, (unsigned long long)queryType,
+                            (unsigned long long)dataSize, (unsigned long long)pData,
+                            (unsigned long long)stride);
+                }
+                VkResult vkWriteMicromapsPropertiesEXT_VkResult_return = (VkResult)0;
+                vkWriteMicromapsPropertiesEXT_VkResult_return = vk->vkWriteMicromapsPropertiesEXT(
+                    unboxed_device, micromapCount, pMicromaps, queryType, dataSize, pData, stride);
+                if ((vkWriteMicromapsPropertiesEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkWriteMicromapsPropertiesEXT_VkResult_return, opcode,
+                                             context);
+                vkStream->unsetHandleMapping();
+                vkStream->write((void*)pData, ((dataSize)) * sizeof(uint8_t));
+                vkStream->write(&vkWriteMicromapsPropertiesEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkWriteMicromapsPropertiesEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkWriteMicromapsPropertiesEXT_VkResult_return, device, micromapCount,
+                        pMicromaps, queryType, dataSize, pData, stride);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyMicromapEXT: {
+                android::base::beginTrace("vkCmdCopyMicromapEXT decode");
+                VkCommandBuffer commandBuffer;
+                const VkCopyMicromapInfoEXT* pInfo;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                vkReadStream->alloc((void**)&pInfo, sizeof(const VkCopyMicromapInfoEXT));
+                reservedunmarshal_VkCopyMicromapInfoEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                        (VkCopyMicromapInfoEXT*)(pInfo),
+                                                        readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyMicromapInfoEXT(m_state,
+                                                           (VkCopyMicromapInfoEXT*)(pInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdCopyMicromapEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer, (unsigned long long)pInfo);
+                }
+                vk->vkCmdCopyMicromapEXT(unboxed_commandBuffer, pInfo);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdCopyMicromapEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, pInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyMicromapToMemoryEXT: {
+                android::base::beginTrace("vkCmdCopyMicromapToMemoryEXT decode");
+                VkCommandBuffer commandBuffer;
+                const VkCopyMicromapToMemoryInfoEXT* pInfo;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                vkReadStream->alloc((void**)&pInfo, sizeof(const VkCopyMicromapToMemoryInfoEXT));
+                reservedunmarshal_VkCopyMicromapToMemoryInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyMicromapToMemoryInfoEXT*)(pInfo), readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyMicromapToMemoryInfoEXT(
+                        m_state, (VkCopyMicromapToMemoryInfoEXT*)(pInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdCopyMicromapToMemoryEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer, (unsigned long long)pInfo);
+                }
+                vk->vkCmdCopyMicromapToMemoryEXT(unboxed_commandBuffer, pInfo);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdCopyMicromapToMemoryEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, pInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyMemoryToMicromapEXT: {
+                android::base::beginTrace("vkCmdCopyMemoryToMicromapEXT decode");
+                VkCommandBuffer commandBuffer;
+                const VkCopyMemoryToMicromapInfoEXT* pInfo;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                vkReadStream->alloc((void**)&pInfo, sizeof(const VkCopyMemoryToMicromapInfoEXT));
+                reservedunmarshal_VkCopyMemoryToMicromapInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyMemoryToMicromapInfoEXT*)(pInfo), readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyMemoryToMicromapInfoEXT(
+                        m_state, (VkCopyMemoryToMicromapInfoEXT*)(pInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdCopyMemoryToMicromapEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer, (unsigned long long)pInfo);
+                }
+                vk->vkCmdCopyMemoryToMicromapEXT(unboxed_commandBuffer, pInfo);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdCopyMemoryToMicromapEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, pInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdWriteMicromapsPropertiesEXT: {
+                android::base::beginTrace("vkCmdWriteMicromapsPropertiesEXT decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t micromapCount;
+                const VkMicromapEXT* pMicromaps;
+                VkQueryType queryType;
+                VkQueryPool queryPool;
+                uint32_t firstQuery;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&micromapCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pMicromaps,
+                                    ((micromapCount)) * sizeof(const VkMicromapEXT));
+                for (uint32_t i = 0; i < (uint32_t)((micromapCount)); ++i) {
+                    memcpy((VkMicromapEXT*)&pMicromaps[i], (*readStreamPtrPtr), 8);
+                    android::base::Stream::fromBe64((uint8_t*)&pMicromaps[i]);
+                    *readStreamPtrPtr += 8;
+                }
+                memcpy((VkQueryType*)&queryType, *readStreamPtrPtr, sizeof(VkQueryType));
+                *readStreamPtrPtr += sizeof(VkQueryType);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkQueryPool*)&queryPool =
+                    (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_1));
+                memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdWriteMicromapsPropertiesEXT 0x%llx 0x%llx 0x%llx "
+                            "0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)micromapCount, (unsigned long long)pMicromaps,
+                            (unsigned long long)queryType, (unsigned long long)queryPool,
+                            (unsigned long long)firstQuery);
+                }
+                vk->vkCmdWriteMicromapsPropertiesEXT(unboxed_commandBuffer, micromapCount,
+                                                     pMicromaps, queryType, queryPool, firstQuery);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdWriteMicromapsPropertiesEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        micromapCount, pMicromaps, queryType, queryPool, firstQuery);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetDeviceMicromapCompatibilityEXT: {
+                android::base::beginTrace("vkGetDeviceMicromapCompatibilityEXT decode");
+                VkDevice device;
+                const VkMicromapVersionInfoEXT* pVersionInfo;
+                VkAccelerationStructureCompatibilityKHR* pCompatibility;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pVersionInfo, sizeof(const VkMicromapVersionInfoEXT));
+                reservedunmarshal_VkMicromapVersionInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkMicromapVersionInfoEXT*)(pVersionInfo), readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pCompatibility;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pCompatibility,
+                                    sizeof(VkAccelerationStructureCompatibilityKHR));
+                memcpy((VkAccelerationStructureCompatibilityKHR*)pCompatibility, *readStreamPtrPtr,
+                       sizeof(VkAccelerationStructureCompatibilityKHR));
+                *readStreamPtrPtr += sizeof(VkAccelerationStructureCompatibilityKHR);
+                if (pVersionInfo) {
+                    transform_tohost_VkMicromapVersionInfoEXT(
+                        m_state, (VkMicromapVersionInfoEXT*)(pVersionInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetDeviceMicromapCompatibilityEXT 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pVersionInfo,
+                            (unsigned long long)pCompatibility);
+                }
+                vk->vkGetDeviceMicromapCompatibilityEXT(unboxed_device, pVersionInfo,
+                                                        pCompatibility);
+                vkStream->unsetHandleMapping();
+                vkStream->write((VkAccelerationStructureCompatibilityKHR*)pCompatibility,
+                                sizeof(VkAccelerationStructureCompatibilityKHR));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetDeviceMicromapCompatibilityEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pVersionInfo,
+                        pCompatibility);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetMicromapBuildSizesEXT: {
+                android::base::beginTrace("vkGetMicromapBuildSizesEXT decode");
+                VkDevice device;
+                VkAccelerationStructureBuildTypeKHR buildType;
+                const VkMicromapBuildInfoEXT* pBuildInfo;
+                VkMicromapBuildSizesInfoEXT* pSizeInfo;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((VkAccelerationStructureBuildTypeKHR*)&buildType, *readStreamPtrPtr,
+                       sizeof(VkAccelerationStructureBuildTypeKHR));
+                *readStreamPtrPtr += sizeof(VkAccelerationStructureBuildTypeKHR);
+                vkReadStream->alloc((void**)&pBuildInfo, sizeof(const VkMicromapBuildInfoEXT));
+                reservedunmarshal_VkMicromapBuildInfoEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                         (VkMicromapBuildInfoEXT*)(pBuildInfo),
+                                                         readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pSizeInfo;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pSizeInfo, sizeof(VkMicromapBuildSizesInfoEXT));
+                reservedunmarshal_VkMicromapBuildSizesInfoEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkMicromapBuildSizesInfoEXT*)(pSizeInfo), readStreamPtrPtr);
+                if (pBuildInfo) {
+                    transform_tohost_VkMicromapBuildInfoEXT(m_state,
+                                                            (VkMicromapBuildInfoEXT*)(pBuildInfo));
+                }
+                if (pSizeInfo) {
+                    transform_tohost_VkMicromapBuildSizesInfoEXT(
+                        m_state, (VkMicromapBuildSizesInfoEXT*)(pSizeInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkGetMicromapBuildSizesEXT 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)device, (unsigned long long)buildType,
+                        (unsigned long long)pBuildInfo, (unsigned long long)pSizeInfo);
+                }
+                vk->vkGetMicromapBuildSizesEXT(unboxed_device, buildType, pBuildInfo, pSizeInfo);
+                vkStream->unsetHandleMapping();
+                if (pSizeInfo) {
+                    transform_fromhost_VkMicromapBuildSizesInfoEXT(
+                        m_state, (VkMicromapBuildSizesInfoEXT*)(pSizeInfo));
+                }
+                marshal_VkMicromapBuildSizesInfoEXT(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                    (VkMicromapBuildSizesInfoEXT*)(pSizeInfo));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetMicromapBuildSizesEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, buildType,
+                        pBuildInfo, pSizeInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_displacement_micromap
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+            case OP_vkCmdDrawClusterHUAWEI: {
+                android::base::beginTrace("vkCmdDrawClusterHUAWEI decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t groupCountX;
+                uint32_t groupCountY;
+                uint32_t groupCountZ;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdDrawClusterHUAWEI 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)groupCountX, (unsigned long long)groupCountY,
+                            (unsigned long long)groupCountZ);
+                }
+                vk->vkCmdDrawClusterHUAWEI(unboxed_commandBuffer, groupCountX, groupCountY,
+                                           groupCountZ);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdDrawClusterHUAWEI(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, groupCountX,
+                        groupCountY, groupCountZ);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawClusterIndirectHUAWEI: {
+                android::base::beginTrace("vkCmdDrawClusterIndirectHUAWEI decode");
+                VkCommandBuffer commandBuffer;
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkCmdDrawClusterIndirectHUAWEI 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)commandBuffer, (unsigned long long)buffer,
+                        (unsigned long long)offset);
+                }
+                vk->vkCmdDrawClusterIndirectHUAWEI(unboxed_commandBuffer, buffer, offset);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdDrawClusterIndirectHUAWEI(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, buffer,
+                        offset);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
 #ifdef VK_EXT_border_color_swizzle
 #endif
 #ifdef VK_EXT_pageable_device_local_memory
@@ -33096,6 +37120,2664 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
                 break;
             }
 #endif
+#ifdef VK_ARM_shader_core_properties
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+            case OP_vkGetDescriptorSetLayoutHostMappingInfoVALVE: {
+                android::base::beginTrace("vkGetDescriptorSetLayoutHostMappingInfoVALVE decode");
+                VkDevice device;
+                const VkDescriptorSetBindingReferenceVALVE* pBindingReference;
+                VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pBindingReference,
+                                    sizeof(const VkDescriptorSetBindingReferenceVALVE));
+                reservedunmarshal_VkDescriptorSetBindingReferenceVALVE(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkDescriptorSetBindingReferenceVALVE*)(pBindingReference), readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pHostMapping;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pHostMapping,
+                                    sizeof(VkDescriptorSetLayoutHostMappingInfoVALVE));
+                reservedunmarshal_VkDescriptorSetLayoutHostMappingInfoVALVE(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkDescriptorSetLayoutHostMappingInfoVALVE*)(pHostMapping), readStreamPtrPtr);
+                if (pBindingReference) {
+                    transform_tohost_VkDescriptorSetBindingReferenceVALVE(
+                        m_state, (VkDescriptorSetBindingReferenceVALVE*)(pBindingReference));
+                }
+                if (pHostMapping) {
+                    transform_tohost_VkDescriptorSetLayoutHostMappingInfoVALVE(
+                        m_state, (VkDescriptorSetLayoutHostMappingInfoVALVE*)(pHostMapping));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetDescriptorSetLayoutHostMappingInfoVALVE 0x%llx "
+                            "0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device,
+                            (unsigned long long)pBindingReference,
+                            (unsigned long long)pHostMapping);
+                }
+                vk->vkGetDescriptorSetLayoutHostMappingInfoVALVE(unboxed_device, pBindingReference,
+                                                                 pHostMapping);
+                vkStream->unsetHandleMapping();
+                if (pHostMapping) {
+                    transform_fromhost_VkDescriptorSetLayoutHostMappingInfoVALVE(
+                        m_state, (VkDescriptorSetLayoutHostMappingInfoVALVE*)(pHostMapping));
+                }
+                marshal_VkDescriptorSetLayoutHostMappingInfoVALVE(
+                    vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkDescriptorSetLayoutHostMappingInfoVALVE*)(pHostMapping));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetDescriptorSetLayoutHostMappingInfoVALVE(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pBindingReference,
+                        pHostMapping);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetDescriptorSetHostMappingVALVE: {
+                android::base::beginTrace("vkGetDescriptorSetHostMappingVALVE decode");
+                VkDevice device;
+                VkDescriptorSet descriptorSet;
+                void** ppData;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDescriptorSet*)&descriptorSet =
+                    (VkDescriptorSet)unbox_VkDescriptorSet((VkDescriptorSet)(*&cgen_var_1));
+                // Begin manual dispatchable handle unboxing for ppData;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&ppData, sizeof(void*));
+                memcpy((void**)ppData, *readStreamPtrPtr, sizeof(void*));
+                *readStreamPtrPtr += sizeof(void*);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetDescriptorSetHostMappingVALVE 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)descriptorSet,
+                            (unsigned long long)ppData);
+                }
+                vk->vkGetDescriptorSetHostMappingVALVE(unboxed_device, descriptorSet, ppData);
+                vkStream->unsetHandleMapping();
+                vkStream->write((void**)ppData, sizeof(void*));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetDescriptorSetHostMappingVALVE(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, descriptorSet,
+                        ppData);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+#endif
+#ifdef VK_NV_copy_memory_indirect
+            case OP_vkCmdCopyMemoryIndirectNV: {
+                android::base::beginTrace("vkCmdCopyMemoryIndirectNV decode");
+                VkCommandBuffer commandBuffer;
+                VkDeviceAddress copyBufferAddress;
+                uint32_t copyCount;
+                uint32_t stride;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkDeviceAddress*)&copyBufferAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                memcpy((uint32_t*)&copyCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkCmdCopyMemoryIndirectNV 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)commandBuffer,
+                        (unsigned long long)copyBufferAddress, (unsigned long long)copyCount,
+                        (unsigned long long)stride);
+                }
+                vk->vkCmdCopyMemoryIndirectNV(unboxed_commandBuffer, copyBufferAddress, copyCount,
+                                              stride);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdCopyMemoryIndirectNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        copyBufferAddress, copyCount, stride);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyMemoryToImageIndirectNV: {
+                android::base::beginTrace("vkCmdCopyMemoryToImageIndirectNV decode");
+                VkCommandBuffer commandBuffer;
+                VkDeviceAddress copyBufferAddress;
+                uint32_t copyCount;
+                uint32_t stride;
+                VkImage dstImage;
+                VkImageLayout dstImageLayout;
+                const VkImageSubresourceLayers* pImageSubresources;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkDeviceAddress*)&copyBufferAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                memcpy((uint32_t*)&copyCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
+                memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
+                *readStreamPtrPtr += sizeof(VkImageLayout);
+                vkReadStream->alloc((void**)&pImageSubresources,
+                                    ((copyCount)) * sizeof(const VkImageSubresourceLayers));
+                for (uint32_t i = 0; i < (uint32_t)((copyCount)); ++i) {
+                    reservedunmarshal_VkImageSubresourceLayers(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkImageSubresourceLayers*)(pImageSubresources + i), readStreamPtrPtr);
+                }
+                if (pImageSubresources) {
+                    for (uint32_t i = 0; i < (uint32_t)((copyCount)); ++i) {
+                        transform_tohost_VkImageSubresourceLayers(
+                            m_state, (VkImageSubresourceLayers*)(pImageSubresources + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdCopyMemoryToImageIndirectNV 0x%llx 0x%llx 0x%llx "
+                            "0x%llx 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)copyBufferAddress, (unsigned long long)copyCount,
+                            (unsigned long long)stride, (unsigned long long)dstImage,
+                            (unsigned long long)dstImageLayout,
+                            (unsigned long long)pImageSubresources);
+                }
+                vk->vkCmdCopyMemoryToImageIndirectNV(unboxed_commandBuffer, copyBufferAddress,
+                                                     copyCount, stride, dstImage, dstImageLayout,
+                                                     pImageSubresources);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdCopyMemoryToImageIndirectNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        copyBufferAddress, copyCount, stride, dstImage, dstImageLayout,
+                        pImageSubresources);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_memory_decompression
+            case OP_vkCmdDecompressMemoryNV: {
+                android::base::beginTrace("vkCmdDecompressMemoryNV decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t decompressRegionCount;
+                const VkDecompressMemoryRegionNV* pDecompressMemoryRegions;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&decompressRegionCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc(
+                    (void**)&pDecompressMemoryRegions,
+                    ((decompressRegionCount)) * sizeof(const VkDecompressMemoryRegionNV));
+                for (uint32_t i = 0; i < (uint32_t)((decompressRegionCount)); ++i) {
+                    reservedunmarshal_VkDecompressMemoryRegionNV(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkDecompressMemoryRegionNV*)(pDecompressMemoryRegions + i),
+                        readStreamPtrPtr);
+                }
+                if (pDecompressMemoryRegions) {
+                    for (uint32_t i = 0; i < (uint32_t)((decompressRegionCount)); ++i) {
+                        transform_tohost_VkDecompressMemoryRegionNV(
+                            m_state, (VkDecompressMemoryRegionNV*)(pDecompressMemoryRegions + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdDecompressMemoryNV 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)decompressRegionCount,
+                            (unsigned long long)pDecompressMemoryRegions);
+                }
+                vk->vkCmdDecompressMemoryNV(unboxed_commandBuffer, decompressRegionCount,
+                                            pDecompressMemoryRegions);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdDecompressMemoryNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        decompressRegionCount, pDecompressMemoryRegions);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDecompressMemoryIndirectCountNV: {
+                android::base::beginTrace("vkCmdDecompressMemoryIndirectCountNV decode");
+                VkCommandBuffer commandBuffer;
+                VkDeviceAddress indirectCommandsAddress;
+                VkDeviceAddress indirectCommandsCountAddress;
+                uint32_t stride;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkDeviceAddress*)&indirectCommandsAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                memcpy((VkDeviceAddress*)&indirectCommandsCountAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdDecompressMemoryIndirectCountNV 0x%llx 0x%llx "
+                            "0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)indirectCommandsAddress,
+                            (unsigned long long)indirectCommandsCountAddress,
+                            (unsigned long long)stride);
+                }
+                vk->vkCmdDecompressMemoryIndirectCountNV(unboxed_commandBuffer,
+                                                         indirectCommandsAddress,
+                                                         indirectCommandsCountAddress, stride);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdDecompressMemoryIndirectCountNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        indirectCommandsAddress, indirectCommandsCountAddress, stride);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_linear_color_attachment
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+#endif
+#ifdef VK_QCOM_image_processing
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+            case OP_vkCmdSetTessellationDomainOriginEXT: {
+                android::base::beginTrace("vkCmdSetTessellationDomainOriginEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkTessellationDomainOrigin domainOrigin;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkTessellationDomainOrigin*)&domainOrigin, *readStreamPtrPtr,
+                       sizeof(VkTessellationDomainOrigin));
+                *readStreamPtrPtr += sizeof(VkTessellationDomainOrigin);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetTessellationDomainOriginEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)domainOrigin);
+                }
+                vk->vkCmdSetTessellationDomainOriginEXT(unboxed_commandBuffer, domainOrigin);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetTessellationDomainOriginEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        domainOrigin);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthClampEnableEXT: {
+                android::base::beginTrace("vkCmdSetDepthClampEnableEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 depthClampEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&depthClampEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetDepthClampEnableEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)depthClampEnable);
+                }
+                vk->vkCmdSetDepthClampEnableEXT(unboxed_commandBuffer, depthClampEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetDepthClampEnableEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        depthClampEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetPolygonModeEXT: {
+                android::base::beginTrace("vkCmdSetPolygonModeEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkPolygonMode polygonMode;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkPolygonMode*)&polygonMode, *readStreamPtrPtr, sizeof(VkPolygonMode));
+                *readStreamPtrPtr += sizeof(VkPolygonMode);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetPolygonModeEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)polygonMode);
+                }
+                vk->vkCmdSetPolygonModeEXT(unboxed_commandBuffer, polygonMode);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetPolygonModeEXT(snapshotTraceBegin,
+                                                                snapshotTraceBytes, &m_pool,
+                                                                commandBuffer, polygonMode);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetRasterizationSamplesEXT: {
+                android::base::beginTrace("vkCmdSetRasterizationSamplesEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkSampleCountFlagBits rasterizationSamples;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkSampleCountFlagBits*)&rasterizationSamples, *readStreamPtrPtr,
+                       sizeof(VkSampleCountFlagBits));
+                *readStreamPtrPtr += sizeof(VkSampleCountFlagBits);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetRasterizationSamplesEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)rasterizationSamples);
+                }
+                vk->vkCmdSetRasterizationSamplesEXT(unboxed_commandBuffer, rasterizationSamples);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetRasterizationSamplesEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        rasterizationSamples);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetSampleMaskEXT: {
+                android::base::beginTrace("vkCmdSetSampleMaskEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkSampleCountFlagBits samples;
+                const VkSampleMask* pSampleMask;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkSampleCountFlagBits*)&samples, *readStreamPtrPtr,
+                       sizeof(VkSampleCountFlagBits));
+                *readStreamPtrPtr += sizeof(VkSampleCountFlagBits);
+                vkReadStream->alloc((void**)&pSampleMask,
+                                    int(samples / 32) * sizeof(const VkSampleMask));
+                memcpy((VkSampleMask*)pSampleMask, *readStreamPtrPtr,
+                       int(samples / 32) * sizeof(const VkSampleMask));
+                *readStreamPtrPtr += int(samples / 32) * sizeof(const VkSampleMask);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetSampleMaskEXT 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)samples, (unsigned long long)pSampleMask);
+                }
+                vk->vkCmdSetSampleMaskEXT(unboxed_commandBuffer, samples, pSampleMask);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetSampleMaskEXT(snapshotTraceBegin,
+                                                               snapshotTraceBytes, &m_pool,
+                                                               commandBuffer, samples, pSampleMask);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetAlphaToCoverageEnableEXT: {
+                android::base::beginTrace("vkCmdSetAlphaToCoverageEnableEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 alphaToCoverageEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&alphaToCoverageEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetAlphaToCoverageEnableEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)alphaToCoverageEnable);
+                }
+                vk->vkCmdSetAlphaToCoverageEnableEXT(unboxed_commandBuffer, alphaToCoverageEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetAlphaToCoverageEnableEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        alphaToCoverageEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetAlphaToOneEnableEXT: {
+                android::base::beginTrace("vkCmdSetAlphaToOneEnableEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 alphaToOneEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&alphaToOneEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetAlphaToOneEnableEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)alphaToOneEnable);
+                }
+                vk->vkCmdSetAlphaToOneEnableEXT(unboxed_commandBuffer, alphaToOneEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetAlphaToOneEnableEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        alphaToOneEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetLogicOpEnableEXT: {
+                android::base::beginTrace("vkCmdSetLogicOpEnableEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 logicOpEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&logicOpEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetLogicOpEnableEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)logicOpEnable);
+                }
+                vk->vkCmdSetLogicOpEnableEXT(unboxed_commandBuffer, logicOpEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetLogicOpEnableEXT(snapshotTraceBegin,
+                                                                  snapshotTraceBytes, &m_pool,
+                                                                  commandBuffer, logicOpEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetColorBlendEnableEXT: {
+                android::base::beginTrace("vkCmdSetColorBlendEnableEXT decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t firstAttachment;
+                uint32_t attachmentCount;
+                const VkBool32* pColorBlendEnables;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pColorBlendEnables,
+                                    ((attachmentCount)) * sizeof(const VkBool32));
+                memcpy((VkBool32*)pColorBlendEnables, *readStreamPtrPtr,
+                       ((attachmentCount)) * sizeof(const VkBool32));
+                *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetColorBlendEnableEXT 0x%llx 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)firstAttachment,
+                            (unsigned long long)attachmentCount,
+                            (unsigned long long)pColorBlendEnables);
+                }
+                vk->vkCmdSetColorBlendEnableEXT(unboxed_commandBuffer, firstAttachment,
+                                                attachmentCount, pColorBlendEnables);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetColorBlendEnableEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        firstAttachment, attachmentCount, pColorBlendEnables);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetColorBlendEquationEXT: {
+                android::base::beginTrace("vkCmdSetColorBlendEquationEXT decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t firstAttachment;
+                uint32_t attachmentCount;
+                const VkColorBlendEquationEXT* pColorBlendEquations;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pColorBlendEquations,
+                                    ((attachmentCount)) * sizeof(const VkColorBlendEquationEXT));
+                for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+                    reservedunmarshal_VkColorBlendEquationEXT(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkColorBlendEquationEXT*)(pColorBlendEquations + i), readStreamPtrPtr);
+                }
+                if (pColorBlendEquations) {
+                    for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+                        transform_tohost_VkColorBlendEquationEXT(
+                            m_state, (VkColorBlendEquationEXT*)(pColorBlendEquations + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetColorBlendEquationEXT 0x%llx 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)firstAttachment,
+                            (unsigned long long)attachmentCount,
+                            (unsigned long long)pColorBlendEquations);
+                }
+                vk->vkCmdSetColorBlendEquationEXT(unboxed_commandBuffer, firstAttachment,
+                                                  attachmentCount, pColorBlendEquations);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetColorBlendEquationEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        firstAttachment, attachmentCount, pColorBlendEquations);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetColorWriteMaskEXT: {
+                android::base::beginTrace("vkCmdSetColorWriteMaskEXT decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t firstAttachment;
+                uint32_t attachmentCount;
+                const VkColorComponentFlags* pColorWriteMasks;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                // WARNING PTR CHECK
+                memcpy((VkColorComponentFlags**)&pColorWriteMasks, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pColorWriteMasks);
+                *readStreamPtrPtr += 8;
+                if (pColorWriteMasks) {
+                    vkReadStream->alloc((void**)&pColorWriteMasks,
+                                        ((attachmentCount)) * sizeof(const VkColorComponentFlags));
+                    memcpy((VkColorComponentFlags*)pColorWriteMasks, *readStreamPtrPtr,
+                           ((attachmentCount)) * sizeof(const VkColorComponentFlags));
+                    *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkColorComponentFlags);
+                }
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkCmdSetColorWriteMaskEXT 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)commandBuffer,
+                        (unsigned long long)firstAttachment, (unsigned long long)attachmentCount,
+                        (unsigned long long)pColorWriteMasks);
+                }
+                vk->vkCmdSetColorWriteMaskEXT(unboxed_commandBuffer, firstAttachment,
+                                              attachmentCount, pColorWriteMasks);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetColorWriteMaskEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        firstAttachment, attachmentCount, pColorWriteMasks);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetRasterizationStreamEXT: {
+                android::base::beginTrace("vkCmdSetRasterizationStreamEXT decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t rasterizationStream;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&rasterizationStream, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetRasterizationStreamEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)rasterizationStream);
+                }
+                vk->vkCmdSetRasterizationStreamEXT(unboxed_commandBuffer, rasterizationStream);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetRasterizationStreamEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        rasterizationStream);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetConservativeRasterizationModeEXT: {
+                android::base::beginTrace("vkCmdSetConservativeRasterizationModeEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkConservativeRasterizationModeEXT conservativeRasterizationMode;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkConservativeRasterizationModeEXT*)&conservativeRasterizationMode,
+                       *readStreamPtrPtr, sizeof(VkConservativeRasterizationModeEXT));
+                *readStreamPtrPtr += sizeof(VkConservativeRasterizationModeEXT);
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkCmdSetConservativeRasterizationModeEXT 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)commandBuffer,
+                        (unsigned long long)conservativeRasterizationMode);
+                }
+                vk->vkCmdSetConservativeRasterizationModeEXT(unboxed_commandBuffer,
+                                                             conservativeRasterizationMode);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetConservativeRasterizationModeEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        conservativeRasterizationMode);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetExtraPrimitiveOverestimationSizeEXT: {
+                android::base::beginTrace("vkCmdSetExtraPrimitiveOverestimationSizeEXT decode");
+                VkCommandBuffer commandBuffer;
+                float extraPrimitiveOverestimationSize;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((float*)&extraPrimitiveOverestimationSize, *readStreamPtrPtr, sizeof(float));
+                *readStreamPtrPtr += sizeof(float);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetExtraPrimitiveOverestimationSizeEXT 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)extraPrimitiveOverestimationSize);
+                }
+                vk->vkCmdSetExtraPrimitiveOverestimationSizeEXT(unboxed_commandBuffer,
+                                                                extraPrimitiveOverestimationSize);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetExtraPrimitiveOverestimationSizeEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        extraPrimitiveOverestimationSize);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthClipEnableEXT: {
+                android::base::beginTrace("vkCmdSetDepthClipEnableEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 depthClipEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&depthClipEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetDepthClipEnableEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)depthClipEnable);
+                }
+                vk->vkCmdSetDepthClipEnableEXT(unboxed_commandBuffer, depthClipEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetDepthClipEnableEXT(snapshotTraceBegin,
+                                                                    snapshotTraceBytes, &m_pool,
+                                                                    commandBuffer, depthClipEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetSampleLocationsEnableEXT: {
+                android::base::beginTrace("vkCmdSetSampleLocationsEnableEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 sampleLocationsEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&sampleLocationsEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetSampleLocationsEnableEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)sampleLocationsEnable);
+                }
+                vk->vkCmdSetSampleLocationsEnableEXT(unboxed_commandBuffer, sampleLocationsEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetSampleLocationsEnableEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        sampleLocationsEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetColorBlendAdvancedEXT: {
+                android::base::beginTrace("vkCmdSetColorBlendAdvancedEXT decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t firstAttachment;
+                uint32_t attachmentCount;
+                const VkColorBlendAdvancedEXT* pColorBlendAdvanced;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pColorBlendAdvanced,
+                                    ((attachmentCount)) * sizeof(const VkColorBlendAdvancedEXT));
+                for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+                    reservedunmarshal_VkColorBlendAdvancedEXT(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkColorBlendAdvancedEXT*)(pColorBlendAdvanced + i), readStreamPtrPtr);
+                }
+                if (pColorBlendAdvanced) {
+                    for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+                        transform_tohost_VkColorBlendAdvancedEXT(
+                            m_state, (VkColorBlendAdvancedEXT*)(pColorBlendAdvanced + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetColorBlendAdvancedEXT 0x%llx 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)firstAttachment,
+                            (unsigned long long)attachmentCount,
+                            (unsigned long long)pColorBlendAdvanced);
+                }
+                vk->vkCmdSetColorBlendAdvancedEXT(unboxed_commandBuffer, firstAttachment,
+                                                  attachmentCount, pColorBlendAdvanced);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetColorBlendAdvancedEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        firstAttachment, attachmentCount, pColorBlendAdvanced);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetProvokingVertexModeEXT: {
+                android::base::beginTrace("vkCmdSetProvokingVertexModeEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkProvokingVertexModeEXT provokingVertexMode;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkProvokingVertexModeEXT*)&provokingVertexMode, *readStreamPtrPtr,
+                       sizeof(VkProvokingVertexModeEXT));
+                *readStreamPtrPtr += sizeof(VkProvokingVertexModeEXT);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetProvokingVertexModeEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)provokingVertexMode);
+                }
+                vk->vkCmdSetProvokingVertexModeEXT(unboxed_commandBuffer, provokingVertexMode);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetProvokingVertexModeEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        provokingVertexMode);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetLineRasterizationModeEXT: {
+                android::base::beginTrace("vkCmdSetLineRasterizationModeEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkLineRasterizationModeEXT lineRasterizationMode;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkLineRasterizationModeEXT*)&lineRasterizationMode, *readStreamPtrPtr,
+                       sizeof(VkLineRasterizationModeEXT));
+                *readStreamPtrPtr += sizeof(VkLineRasterizationModeEXT);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetLineRasterizationModeEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)lineRasterizationMode);
+                }
+                vk->vkCmdSetLineRasterizationModeEXT(unboxed_commandBuffer, lineRasterizationMode);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetLineRasterizationModeEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        lineRasterizationMode);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetLineStippleEnableEXT: {
+                android::base::beginTrace("vkCmdSetLineStippleEnableEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 stippledLineEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&stippledLineEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkCmdSetLineStippleEnableEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)stippledLineEnable);
+                }
+                vk->vkCmdSetLineStippleEnableEXT(unboxed_commandBuffer, stippledLineEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetLineStippleEnableEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        stippledLineEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthClipNegativeOneToOneEXT: {
+                android::base::beginTrace("vkCmdSetDepthClipNegativeOneToOneEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 negativeOneToOne;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&negativeOneToOne, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetDepthClipNegativeOneToOneEXT 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)negativeOneToOne);
+                }
+                vk->vkCmdSetDepthClipNegativeOneToOneEXT(unboxed_commandBuffer, negativeOneToOne);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetDepthClipNegativeOneToOneEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        negativeOneToOne);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetViewportWScalingEnableNV: {
+                android::base::beginTrace("vkCmdSetViewportWScalingEnableNV decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 viewportWScalingEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&viewportWScalingEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetViewportWScalingEnableNV 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)viewportWScalingEnable);
+                }
+                vk->vkCmdSetViewportWScalingEnableNV(unboxed_commandBuffer, viewportWScalingEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetViewportWScalingEnableNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        viewportWScalingEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetViewportSwizzleNV: {
+                android::base::beginTrace("vkCmdSetViewportSwizzleNV decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t firstViewport;
+                uint32_t viewportCount;
+                const VkViewportSwizzleNV* pViewportSwizzles;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pViewportSwizzles,
+                                    ((viewportCount)) * sizeof(const VkViewportSwizzleNV));
+                for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                    reservedunmarshal_VkViewportSwizzleNV(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkViewportSwizzleNV*)(pViewportSwizzles + i), readStreamPtrPtr);
+                }
+                if (pViewportSwizzles) {
+                    for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                        transform_tohost_VkViewportSwizzleNV(
+                            m_state, (VkViewportSwizzleNV*)(pViewportSwizzles + i));
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkCmdSetViewportSwizzleNV 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)commandBuffer,
+                        (unsigned long long)firstViewport, (unsigned long long)viewportCount,
+                        (unsigned long long)pViewportSwizzles);
+                }
+                vk->vkCmdSetViewportSwizzleNV(unboxed_commandBuffer, firstViewport, viewportCount,
+                                              pViewportSwizzles);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetViewportSwizzleNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        firstViewport, viewportCount, pViewportSwizzles);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageToColorEnableNV: {
+                android::base::beginTrace("vkCmdSetCoverageToColorEnableNV decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 coverageToColorEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&coverageToColorEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetCoverageToColorEnableNV 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)coverageToColorEnable);
+                }
+                vk->vkCmdSetCoverageToColorEnableNV(unboxed_commandBuffer, coverageToColorEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetCoverageToColorEnableNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        coverageToColorEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageToColorLocationNV: {
+                android::base::beginTrace("vkCmdSetCoverageToColorLocationNV decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t coverageToColorLocation;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&coverageToColorLocation, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetCoverageToColorLocationNV 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)coverageToColorLocation);
+                }
+                vk->vkCmdSetCoverageToColorLocationNV(unboxed_commandBuffer,
+                                                      coverageToColorLocation);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetCoverageToColorLocationNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        coverageToColorLocation);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageModulationModeNV: {
+                android::base::beginTrace("vkCmdSetCoverageModulationModeNV decode");
+                VkCommandBuffer commandBuffer;
+                VkCoverageModulationModeNV coverageModulationMode;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkCoverageModulationModeNV*)&coverageModulationMode, *readStreamPtrPtr,
+                       sizeof(VkCoverageModulationModeNV));
+                *readStreamPtrPtr += sizeof(VkCoverageModulationModeNV);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetCoverageModulationModeNV 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)coverageModulationMode);
+                }
+                vk->vkCmdSetCoverageModulationModeNV(unboxed_commandBuffer, coverageModulationMode);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetCoverageModulationModeNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        coverageModulationMode);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageModulationTableEnableNV: {
+                android::base::beginTrace("vkCmdSetCoverageModulationTableEnableNV decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 coverageModulationTableEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&coverageModulationTableEnable, *readStreamPtrPtr,
+                       sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkCmdSetCoverageModulationTableEnableNV 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)commandBuffer,
+                        (unsigned long long)coverageModulationTableEnable);
+                }
+                vk->vkCmdSetCoverageModulationTableEnableNV(unboxed_commandBuffer,
+                                                            coverageModulationTableEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetCoverageModulationTableEnableNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        coverageModulationTableEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageModulationTableNV: {
+                android::base::beginTrace("vkCmdSetCoverageModulationTableNV decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t coverageModulationTableCount;
+                const float* pCoverageModulationTable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&coverageModulationTableCount, *readStreamPtrPtr,
+                       sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pCoverageModulationTable,
+                                    ((coverageModulationTableCount)) * sizeof(const float));
+                memcpy((float*)pCoverageModulationTable, *readStreamPtrPtr,
+                       ((coverageModulationTableCount)) * sizeof(const float));
+                *readStreamPtrPtr += ((coverageModulationTableCount)) * sizeof(const float);
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkCmdSetCoverageModulationTableNV 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)commandBuffer,
+                        (unsigned long long)coverageModulationTableCount,
+                        (unsigned long long)pCoverageModulationTable);
+                }
+                vk->vkCmdSetCoverageModulationTableNV(
+                    unboxed_commandBuffer, coverageModulationTableCount, pCoverageModulationTable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetCoverageModulationTableNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        coverageModulationTableCount, pCoverageModulationTable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetShadingRateImageEnableNV: {
+                android::base::beginTrace("vkCmdSetShadingRateImageEnableNV decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 shadingRateImageEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&shadingRateImageEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetShadingRateImageEnableNV 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)shadingRateImageEnable);
+                }
+                vk->vkCmdSetShadingRateImageEnableNV(unboxed_commandBuffer, shadingRateImageEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetShadingRateImageEnableNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        shadingRateImageEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetRepresentativeFragmentTestEnableNV: {
+                android::base::beginTrace("vkCmdSetRepresentativeFragmentTestEnableNV decode");
+                VkCommandBuffer commandBuffer;
+                VkBool32 representativeFragmentTestEnable;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkBool32*)&representativeFragmentTestEnable, *readStreamPtrPtr,
+                       sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetRepresentativeFragmentTestEnableNV 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)representativeFragmentTestEnable);
+                }
+                vk->vkCmdSetRepresentativeFragmentTestEnableNV(unboxed_commandBuffer,
+                                                               representativeFragmentTestEnable);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetRepresentativeFragmentTestEnableNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        representativeFragmentTestEnable);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageReductionModeNV: {
+                android::base::beginTrace("vkCmdSetCoverageReductionModeNV decode");
+                VkCommandBuffer commandBuffer;
+                VkCoverageReductionModeNV coverageReductionMode;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkCoverageReductionModeNV*)&coverageReductionMode, *readStreamPtrPtr,
+                       sizeof(VkCoverageReductionModeNV));
+                *readStreamPtrPtr += sizeof(VkCoverageReductionModeNV);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdSetCoverageReductionModeNV 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)coverageReductionMode);
+                }
+                vk->vkCmdSetCoverageReductionModeNV(unboxed_commandBuffer, coverageReductionMode);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetCoverageReductionModeNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer,
+                        coverageReductionMode);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+#endif
+#ifdef VK_EXT_shader_module_identifier
+            case OP_vkGetShaderModuleIdentifierEXT: {
+                android::base::beginTrace("vkGetShaderModuleIdentifierEXT decode");
+                VkDevice device;
+                VkShaderModule shaderModule;
+                VkShaderModuleIdentifierEXT* pIdentifier;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkShaderModule*)&shaderModule =
+                    (VkShaderModule)unbox_VkShaderModule((VkShaderModule)(*&cgen_var_1));
+                // Begin manual dispatchable handle unboxing for pIdentifier;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pIdentifier, sizeof(VkShaderModuleIdentifierEXT));
+                reservedunmarshal_VkShaderModuleIdentifierEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkShaderModuleIdentifierEXT*)(pIdentifier), readStreamPtrPtr);
+                if (pIdentifier) {
+                    transform_tohost_VkShaderModuleIdentifierEXT(
+                        m_state, (VkShaderModuleIdentifierEXT*)(pIdentifier));
+                }
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkGetShaderModuleIdentifierEXT 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)device, (unsigned long long)shaderModule,
+                        (unsigned long long)pIdentifier);
+                }
+                vk->vkGetShaderModuleIdentifierEXT(unboxed_device, shaderModule, pIdentifier);
+                vkStream->unsetHandleMapping();
+                if (pIdentifier) {
+                    transform_fromhost_VkShaderModuleIdentifierEXT(
+                        m_state, (VkShaderModuleIdentifierEXT*)(pIdentifier));
+                }
+                marshal_VkShaderModuleIdentifierEXT(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                    (VkShaderModuleIdentifierEXT*)(pIdentifier));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetShaderModuleIdentifierEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, shaderModule,
+                        pIdentifier);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetShaderModuleCreateInfoIdentifierEXT: {
+                android::base::beginTrace("vkGetShaderModuleCreateInfoIdentifierEXT decode");
+                VkDevice device;
+                const VkShaderModuleCreateInfo* pCreateInfo;
+                VkShaderModuleIdentifierEXT* pIdentifier;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pCreateInfo, sizeof(const VkShaderModuleCreateInfo));
+                reservedunmarshal_VkShaderModuleCreateInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                           (VkShaderModuleCreateInfo*)(pCreateInfo),
+                                                           readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pIdentifier;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pIdentifier, sizeof(VkShaderModuleIdentifierEXT));
+                reservedunmarshal_VkShaderModuleIdentifierEXT(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkShaderModuleIdentifierEXT*)(pIdentifier), readStreamPtrPtr);
+                if (pCreateInfo) {
+                    transform_tohost_VkShaderModuleCreateInfo(
+                        m_state, (VkShaderModuleCreateInfo*)(pCreateInfo));
+                }
+                if (pIdentifier) {
+                    transform_tohost_VkShaderModuleIdentifierEXT(
+                        m_state, (VkShaderModuleIdentifierEXT*)(pIdentifier));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetShaderModuleCreateInfoIdentifierEXT 0x%llx "
+                            "0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
+                            (unsigned long long)pIdentifier);
+                }
+                vk->vkGetShaderModuleCreateInfoIdentifierEXT(unboxed_device, pCreateInfo,
+                                                             pIdentifier);
+                vkStream->unsetHandleMapping();
+                if (pIdentifier) {
+                    transform_fromhost_VkShaderModuleIdentifierEXT(
+                        m_state, (VkShaderModuleIdentifierEXT*)(pIdentifier));
+                }
+                marshal_VkShaderModuleIdentifierEXT(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                    (VkShaderModuleIdentifierEXT*)(pIdentifier));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetShaderModuleCreateInfoIdentifierEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, device, pCreateInfo,
+                        pIdentifier);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+            case OP_vkGetPhysicalDeviceOpticalFlowImageFormatsNV: {
+                android::base::beginTrace("vkGetPhysicalDeviceOpticalFlowImageFormatsNV decode");
+                VkPhysicalDevice physicalDevice;
+                const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo;
+                uint32_t* pFormatCount;
+                VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties;
+                // Begin non wrapped dispatchable handle unboxing for physicalDevice;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkPhysicalDevice*)&physicalDevice =
+                    (VkPhysicalDevice)(VkPhysicalDevice)((VkPhysicalDevice)(*&cgen_var_0));
+                auto unboxed_physicalDevice = unbox_VkPhysicalDevice(physicalDevice);
+                auto vk = dispatch_VkPhysicalDevice(physicalDevice);
+                // End manual dispatchable handle unboxing for physicalDevice;
+                vkReadStream->alloc((void**)&pOpticalFlowImageFormatInfo,
+                                    sizeof(const VkOpticalFlowImageFormatInfoNV));
+                reservedunmarshal_VkOpticalFlowImageFormatInfoNV(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkOpticalFlowImageFormatInfoNV*)(pOpticalFlowImageFormatInfo),
+                    readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pFormatCount;
+                vkReadStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                memcpy((uint32_t**)&pFormatCount, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pFormatCount);
+                *readStreamPtrPtr += 8;
+                if (pFormatCount) {
+                    vkReadStream->alloc((void**)&pFormatCount, sizeof(uint32_t));
+                    memcpy((uint32_t*)pFormatCount, *readStreamPtrPtr, sizeof(uint32_t));
+                    *readStreamPtrPtr += sizeof(uint32_t);
+                }
+                // Begin manual dispatchable handle unboxing for pImageFormatProperties;
+                vkReadStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                memcpy((VkOpticalFlowImageFormatPropertiesNV**)&pImageFormatProperties,
+                       (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pImageFormatProperties);
+                *readStreamPtrPtr += 8;
+                if (pImageFormatProperties) {
+                    vkReadStream->alloc(
+                        (void**)&pImageFormatProperties,
+                        (*(pFormatCount)) * sizeof(VkOpticalFlowImageFormatPropertiesNV));
+                    for (uint32_t i = 0; i < (uint32_t)(*(pFormatCount)); ++i) {
+                        reservedunmarshal_VkOpticalFlowImageFormatPropertiesNV(
+                            vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                            (VkOpticalFlowImageFormatPropertiesNV*)(pImageFormatProperties + i),
+                            readStreamPtrPtr);
+                    }
+                }
+                if (pOpticalFlowImageFormatInfo) {
+                    transform_tohost_VkOpticalFlowImageFormatInfoNV(
+                        m_state, (VkOpticalFlowImageFormatInfoNV*)(pOpticalFlowImageFormatInfo));
+                }
+                if (pFormatCount) {
+                    if (pImageFormatProperties) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pFormatCount)); ++i) {
+                            transform_tohost_VkOpticalFlowImageFormatPropertiesNV(
+                                m_state,
+                                (VkOpticalFlowImageFormatPropertiesNV*)(pImageFormatProperties +
+                                                                        i));
+                        }
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetPhysicalDeviceOpticalFlowImageFormatsNV 0x%llx "
+                            "0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)physicalDevice,
+                            (unsigned long long)pOpticalFlowImageFormatInfo,
+                            (unsigned long long)pFormatCount,
+                            (unsigned long long)pImageFormatProperties);
+                }
+                VkResult vkGetPhysicalDeviceOpticalFlowImageFormatsNV_VkResult_return = (VkResult)0;
+                vkGetPhysicalDeviceOpticalFlowImageFormatsNV_VkResult_return =
+                    vk->vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
+                        unboxed_physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount,
+                        pImageFormatProperties);
+                if ((vkGetPhysicalDeviceOpticalFlowImageFormatsNV_VkResult_return) ==
+                    VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(
+                    vkGetPhysicalDeviceOpticalFlowImageFormatsNV_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                uint64_t cgen_var_3 = (uint64_t)(uintptr_t)pFormatCount;
+                vkStream->putBe64(cgen_var_3);
+                if (pFormatCount) {
+                    vkStream->write((uint32_t*)pFormatCount, sizeof(uint32_t));
+                }
+                if (pFormatCount) {
+                    if (pImageFormatProperties) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pFormatCount)); ++i) {
+                            transform_fromhost_VkOpticalFlowImageFormatPropertiesNV(
+                                m_state,
+                                (VkOpticalFlowImageFormatPropertiesNV*)(pImageFormatProperties +
+                                                                        i));
+                        }
+                    }
+                }
+                // WARNING PTR CHECK
+                uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pImageFormatProperties;
+                vkStream->putBe64(cgen_var_4);
+                if (pImageFormatProperties) {
+                    if (pFormatCount) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pFormatCount)); ++i) {
+                            marshal_VkOpticalFlowImageFormatPropertiesNV(
+                                vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                (VkOpticalFlowImageFormatPropertiesNV*)(pImageFormatProperties +
+                                                                        i));
+                        }
+                    }
+                }
+                vkStream->write(&vkGetPhysicalDeviceOpticalFlowImageFormatsNV_VkResult_return,
+                                sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkGetPhysicalDeviceOpticalFlowImageFormatsNV_VkResult_return,
+                        physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount,
+                        pImageFormatProperties);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCreateOpticalFlowSessionNV: {
+                android::base::beginTrace("vkCreateOpticalFlowSessionNV decode");
+                VkDevice device;
+                const VkOpticalFlowSessionCreateInfoNV* pCreateInfo;
+                const VkAllocationCallbacks* pAllocator;
+                VkOpticalFlowSessionNV* pSession;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pCreateInfo,
+                                    sizeof(const VkOpticalFlowSessionCreateInfoNV));
+                reservedunmarshal_VkOpticalFlowSessionCreateInfoNV(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkOpticalFlowSessionCreateInfoNV*)(pCreateInfo), readStreamPtrPtr);
+                // WARNING PTR CHECK
+                memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pAllocator);
+                *readStreamPtrPtr += 8;
+                if (pAllocator) {
+                    vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
+                    reservedunmarshal_VkAllocationCallbacks(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
+                }
+                // Begin manual dispatchable handle unboxing for pSession;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pSession, sizeof(VkOpticalFlowSessionNV));
+                memcpy((VkOpticalFlowSessionNV*)&(*pSession), (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&(*pSession));
+                *readStreamPtrPtr += 8;
+                if (pCreateInfo) {
+                    transform_tohost_VkOpticalFlowSessionCreateInfoNV(
+                        m_state, (VkOpticalFlowSessionCreateInfoNV*)(pCreateInfo));
+                }
+                if (pAllocator) {
+                    transform_tohost_VkAllocationCallbacks(m_state,
+                                                           (VkAllocationCallbacks*)(pAllocator));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCreateOpticalFlowSessionNV 0x%llx 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)pCreateInfo,
+                            (unsigned long long)pAllocator, (unsigned long long)pSession);
+                }
+                VkResult vkCreateOpticalFlowSessionNV_VkResult_return = (VkResult)0;
+                vkCreateOpticalFlowSessionNV_VkResult_return = vk->vkCreateOpticalFlowSessionNV(
+                    unboxed_device, pCreateInfo, pAllocator, pSession);
+                if ((vkCreateOpticalFlowSessionNV_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkCreateOpticalFlowSessionNV_VkResult_return, opcode,
+                                             context);
+                vkStream->unsetHandleMapping();
+                uint64_t cgen_var_3 = (uint64_t)(*pSession);
+                vkStream->putBe64(cgen_var_3);
+                vkStream->write(&vkCreateOpticalFlowSessionNV_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCreateOpticalFlowSessionNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkCreateOpticalFlowSessionNV_VkResult_return, device, pCreateInfo,
+                        pAllocator, pSession);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkDestroyOpticalFlowSessionNV: {
+                android::base::beginTrace("vkDestroyOpticalFlowSessionNV decode");
+                VkDevice device;
+                VkOpticalFlowSessionNV session;
+                const VkAllocationCallbacks* pAllocator;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((VkOpticalFlowSessionNV*)&session, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&session);
+                *readStreamPtrPtr += 8;
+                // WARNING PTR CHECK
+                memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pAllocator);
+                *readStreamPtrPtr += 8;
+                if (pAllocator) {
+                    vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
+                    reservedunmarshal_VkAllocationCallbacks(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
+                }
+                if (pAllocator) {
+                    transform_tohost_VkAllocationCallbacks(m_state,
+                                                           (VkAllocationCallbacks*)(pAllocator));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkDestroyOpticalFlowSessionNV 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)session,
+                            (unsigned long long)pAllocator);
+                }
+                vk->vkDestroyOpticalFlowSessionNV(unboxed_device, session, pAllocator);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkDestroyOpticalFlowSessionNV(snapshotTraceBegin,
+                                                                       snapshotTraceBytes, &m_pool,
+                                                                       device, session, pAllocator);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkBindOpticalFlowSessionImageNV: {
+                android::base::beginTrace("vkBindOpticalFlowSessionImageNV decode");
+                VkDevice device;
+                VkOpticalFlowSessionNV session;
+                VkOpticalFlowSessionBindingPointNV bindingPoint;
+                VkImageView view;
+                VkImageLayout layout;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((VkOpticalFlowSessionNV*)&session, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&session);
+                *readStreamPtrPtr += 8;
+                memcpy((VkOpticalFlowSessionBindingPointNV*)&bindingPoint, *readStreamPtrPtr,
+                       sizeof(VkOpticalFlowSessionBindingPointNV));
+                *readStreamPtrPtr += sizeof(VkOpticalFlowSessionBindingPointNV);
+                uint64_t cgen_var_2;
+                memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkImageView*)&view = (VkImageView)unbox_VkImageView((VkImageView)(*&cgen_var_2));
+                memcpy((VkImageLayout*)&layout, *readStreamPtrPtr, sizeof(VkImageLayout));
+                *readStreamPtrPtr += sizeof(VkImageLayout);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkBindOpticalFlowSessionImageNV 0x%llx 0x%llx 0x%llx "
+                            "0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)session,
+                            (unsigned long long)bindingPoint, (unsigned long long)view,
+                            (unsigned long long)layout);
+                }
+                VkResult vkBindOpticalFlowSessionImageNV_VkResult_return = (VkResult)0;
+                vkBindOpticalFlowSessionImageNV_VkResult_return =
+                    vk->vkBindOpticalFlowSessionImageNV(unboxed_device, session, bindingPoint, view,
+                                                        layout);
+                if ((vkBindOpticalFlowSessionImageNV_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkBindOpticalFlowSessionImageNV_VkResult_return,
+                                             opcode, context);
+                vkStream->unsetHandleMapping();
+                vkStream->write(&vkBindOpticalFlowSessionImageNV_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkBindOpticalFlowSessionImageNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkBindOpticalFlowSessionImageNV_VkResult_return, device, session,
+                        bindingPoint, view, layout);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdOpticalFlowExecuteNV: {
+                android::base::beginTrace("vkCmdOpticalFlowExecuteNV decode");
+                VkCommandBuffer commandBuffer;
+                VkOpticalFlowSessionNV session;
+                const VkOpticalFlowExecuteInfoNV* pExecuteInfo;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkOpticalFlowSessionNV*)&session, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&session);
+                *readStreamPtrPtr += 8;
+                vkReadStream->alloc((void**)&pExecuteInfo,
+                                    sizeof(const VkOpticalFlowExecuteInfoNV));
+                reservedunmarshal_VkOpticalFlowExecuteInfoNV(
+                    vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkOpticalFlowExecuteInfoNV*)(pExecuteInfo), readStreamPtrPtr);
+                if (pExecuteInfo) {
+                    transform_tohost_VkOpticalFlowExecuteInfoNV(
+                        m_state, (VkOpticalFlowExecuteInfoNV*)(pExecuteInfo));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdOpticalFlowExecuteNV 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)session, (unsigned long long)pExecuteInfo);
+                }
+                vk->vkCmdOpticalFlowExecuteNV(unboxed_commandBuffer, session, pExecuteInfo);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdOpticalFlowExecuteNV(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, session,
+                        pExecuteInfo);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_legacy_dithering
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+#endif
+#ifdef VK_EXT_shader_object
+            case OP_vkCreateShadersEXT: {
+                android::base::beginTrace("vkCreateShadersEXT decode");
+                VkDevice device;
+                uint32_t createInfoCount;
+                const VkShaderCreateInfoEXT* pCreateInfos;
+                const VkAllocationCallbacks* pAllocator;
+                VkShaderEXT* pShaders;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((uint32_t*)&createInfoCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pCreateInfos,
+                                    ((createInfoCount)) * sizeof(const VkShaderCreateInfoEXT));
+                for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+                    reservedunmarshal_VkShaderCreateInfoEXT(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkShaderCreateInfoEXT*)(pCreateInfos + i), readStreamPtrPtr);
+                }
+                // WARNING PTR CHECK
+                memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pAllocator);
+                *readStreamPtrPtr += 8;
+                if (pAllocator) {
+                    vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
+                    reservedunmarshal_VkAllocationCallbacks(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
+                }
+                // Begin manual dispatchable handle unboxing for pShaders;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pShaders, ((createInfoCount)) * sizeof(VkShaderEXT));
+                for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+                    memcpy((VkShaderEXT*)&pShaders[i], (*readStreamPtrPtr), 8);
+                    android::base::Stream::fromBe64((uint8_t*)&pShaders[i]);
+                    *readStreamPtrPtr += 8;
+                }
+                if (pCreateInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+                        transform_tohost_VkShaderCreateInfoEXT(
+                            m_state, (VkShaderCreateInfoEXT*)(pCreateInfos + i));
+                    }
+                }
+                if (pAllocator) {
+                    transform_tohost_VkAllocationCallbacks(m_state,
+                                                           (VkAllocationCallbacks*)(pAllocator));
+                }
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkCreateShadersEXT 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)device, (unsigned long long)createInfoCount,
+                        (unsigned long long)pCreateInfos, (unsigned long long)pAllocator,
+                        (unsigned long long)pShaders);
+                }
+                VkResult vkCreateShadersEXT_VkResult_return = (VkResult)0;
+                vkCreateShadersEXT_VkResult_return = vk->vkCreateShadersEXT(
+                    unboxed_device, createInfoCount, pCreateInfos, pAllocator, pShaders);
+                if ((vkCreateShadersEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkCreateShadersEXT_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                for (uint32_t i = 0; i < (uint32_t)((createInfoCount)); ++i) {
+                    uint64_t cgen_var_1_0 = (uint64_t)pShaders[i];
+                    vkStream->putBe64(cgen_var_1_0);
+                }
+                vkStream->write(&vkCreateShadersEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCreateShadersEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkCreateShadersEXT_VkResult_return, device, createInfoCount, pCreateInfos,
+                        pAllocator, pShaders);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkDestroyShaderEXT: {
+                android::base::beginTrace("vkDestroyShaderEXT decode");
+                VkDevice device;
+                VkShaderEXT shader;
+                const VkAllocationCallbacks* pAllocator;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((VkShaderEXT*)&shader, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&shader);
+                *readStreamPtrPtr += 8;
+                // WARNING PTR CHECK
+                memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pAllocator);
+                *readStreamPtrPtr += 8;
+                if (pAllocator) {
+                    vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
+                    reservedunmarshal_VkAllocationCallbacks(
+                        vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
+                }
+                if (pAllocator) {
+                    transform_tohost_VkAllocationCallbacks(m_state,
+                                                           (VkAllocationCallbacks*)(pAllocator));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr, "stream %p: call vkDestroyShaderEXT 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)shader,
+                            (unsigned long long)pAllocator);
+                }
+                vk->vkDestroyShaderEXT(unboxed_device, shader, pAllocator);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkDestroyShaderEXT(snapshotTraceBegin, snapshotTraceBytes,
+                                                            &m_pool, device, shader, pAllocator);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetShaderBinaryDataEXT: {
+                android::base::beginTrace("vkGetShaderBinaryDataEXT decode");
+                VkDevice device;
+                VkShaderEXT shader;
+                size_t* pDataSize;
+                void* pData;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                memcpy((VkShaderEXT*)&shader, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&shader);
+                *readStreamPtrPtr += 8;
+                // Begin manual dispatchable handle unboxing for pDataSize;
+                vkReadStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                memcpy((size_t**)&pDataSize, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pDataSize);
+                *readStreamPtrPtr += 8;
+                if (pDataSize) {
+                    vkReadStream->alloc((void**)&pDataSize, sizeof(size_t));
+                    memcpy((size_t*)&(*pDataSize), (*readStreamPtrPtr), 8);
+                    android::base::Stream::fromBe64((uint8_t*)&(*pDataSize));
+                    *readStreamPtrPtr += 8;
+                }
+                // Begin manual dispatchable handle unboxing for pData;
+                vkReadStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                memcpy((void**)&pData, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pData);
+                *readStreamPtrPtr += 8;
+                if (pData) {
+                    vkReadStream->alloc((void**)&pData, (*(pDataSize)) * sizeof(uint8_t));
+                    memcpy((void*)pData, *readStreamPtrPtr, (*(pDataSize)) * sizeof(uint8_t));
+                    *readStreamPtrPtr += (*(pDataSize)) * sizeof(uint8_t);
+                }
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkGetShaderBinaryDataEXT 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)device, (unsigned long long)shader,
+                        (unsigned long long)pDataSize, (unsigned long long)pData);
+                }
+                VkResult vkGetShaderBinaryDataEXT_VkResult_return = (VkResult)0;
+                vkGetShaderBinaryDataEXT_VkResult_return =
+                    vk->vkGetShaderBinaryDataEXT(unboxed_device, shader, pDataSize, pData);
+                if ((vkGetShaderBinaryDataEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkGetShaderBinaryDataEXT_VkResult_return, opcode,
+                                             context);
+                vkStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pDataSize;
+                vkStream->putBe64(cgen_var_4);
+                if (pDataSize) {
+                    uint64_t cgen_var_4_0 = (uint64_t)(*pDataSize);
+                    vkStream->putBe64(cgen_var_4_0);
+                }
+                // WARNING PTR CHECK
+                uint64_t cgen_var_5 = (uint64_t)(uintptr_t)pData;
+                vkStream->putBe64(cgen_var_5);
+                if (pData) {
+                    vkStream->write((void*)pData, (*(pDataSize)) * sizeof(uint8_t));
+                }
+                vkStream->write(&vkGetShaderBinaryDataEXT_VkResult_return, sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetShaderBinaryDataEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkGetShaderBinaryDataEXT_VkResult_return, device, shader, pDataSize, pData);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBindShadersEXT: {
+                android::base::beginTrace("vkCmdBindShadersEXT decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t stageCount;
+                const VkShaderStageFlagBits* pStages;
+                const VkShaderEXT* pShaders;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&stageCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vkReadStream->alloc((void**)&pStages,
+                                    ((stageCount)) * sizeof(const VkShaderStageFlagBits));
+                memcpy((VkShaderStageFlagBits*)pStages, *readStreamPtrPtr,
+                       ((stageCount)) * sizeof(const VkShaderStageFlagBits));
+                *readStreamPtrPtr += ((stageCount)) * sizeof(const VkShaderStageFlagBits);
+                // WARNING PTR CHECK
+                memcpy((VkShaderEXT**)&pShaders, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pShaders);
+                *readStreamPtrPtr += 8;
+                if (pShaders) {
+                    vkReadStream->alloc((void**)&pShaders,
+                                        ((stageCount)) * sizeof(const VkShaderEXT));
+                    for (uint32_t i = 0; i < (uint32_t)((stageCount)); ++i) {
+                        memcpy((VkShaderEXT*)&pShaders[i], (*readStreamPtrPtr), 8);
+                        android::base::Stream::fromBe64((uint8_t*)&pShaders[i]);
+                        *readStreamPtrPtr += 8;
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdBindShadersEXT 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)stageCount, (unsigned long long)pStages,
+                            (unsigned long long)pShaders);
+                }
+                vk->vkCmdBindShadersEXT(unboxed_commandBuffer, stageCount, pStages, pShaders);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdBindShadersEXT(snapshotTraceBegin, snapshotTraceBytes,
+                                                             &m_pool, commandBuffer, stageCount,
+                                                             pStages, pShaders);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_QCOM_tile_properties
+            case OP_vkGetFramebufferTilePropertiesQCOM: {
+                android::base::beginTrace("vkGetFramebufferTilePropertiesQCOM decode");
+                VkDevice device;
+                VkFramebuffer framebuffer;
+                uint32_t* pPropertiesCount;
+                VkTilePropertiesQCOM* pProperties;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkFramebuffer*)&framebuffer =
+                    (VkFramebuffer)unbox_VkFramebuffer((VkFramebuffer)(*&cgen_var_1));
+                // Begin manual dispatchable handle unboxing for pPropertiesCount;
+                vkReadStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                memcpy((uint32_t**)&pPropertiesCount, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pPropertiesCount);
+                *readStreamPtrPtr += 8;
+                if (pPropertiesCount) {
+                    vkReadStream->alloc((void**)&pPropertiesCount, sizeof(uint32_t));
+                    memcpy((uint32_t*)pPropertiesCount, *readStreamPtrPtr, sizeof(uint32_t));
+                    *readStreamPtrPtr += sizeof(uint32_t);
+                }
+                // Begin manual dispatchable handle unboxing for pProperties;
+                vkReadStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                memcpy((VkTilePropertiesQCOM**)&pProperties, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pProperties);
+                *readStreamPtrPtr += 8;
+                if (pProperties) {
+                    vkReadStream->alloc((void**)&pProperties,
+                                        (*(pPropertiesCount)) * sizeof(VkTilePropertiesQCOM));
+                    for (uint32_t i = 0; i < (uint32_t)(*(pPropertiesCount)); ++i) {
+                        reservedunmarshal_VkTilePropertiesQCOM(
+                            vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                            (VkTilePropertiesQCOM*)(pProperties + i), readStreamPtrPtr);
+                    }
+                }
+                if (pPropertiesCount) {
+                    if (pProperties) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pPropertiesCount)); ++i) {
+                            transform_tohost_VkTilePropertiesQCOM(
+                                m_state, (VkTilePropertiesQCOM*)(pProperties + i));
+                        }
+                    }
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetFramebufferTilePropertiesQCOM 0x%llx 0x%llx "
+                            "0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)device, (unsigned long long)framebuffer,
+                            (unsigned long long)pPropertiesCount, (unsigned long long)pProperties);
+                }
+                VkResult vkGetFramebufferTilePropertiesQCOM_VkResult_return = (VkResult)0;
+                vkGetFramebufferTilePropertiesQCOM_VkResult_return =
+                    vk->vkGetFramebufferTilePropertiesQCOM(unboxed_device, framebuffer,
+                                                           pPropertiesCount, pProperties);
+                if ((vkGetFramebufferTilePropertiesQCOM_VkResult_return) == VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(vkGetFramebufferTilePropertiesQCOM_VkResult_return,
+                                             opcode, context);
+                vkStream->unsetHandleMapping();
+                // WARNING PTR CHECK
+                uint64_t cgen_var_4 = (uint64_t)(uintptr_t)pPropertiesCount;
+                vkStream->putBe64(cgen_var_4);
+                if (pPropertiesCount) {
+                    vkStream->write((uint32_t*)pPropertiesCount, sizeof(uint32_t));
+                }
+                if (pPropertiesCount) {
+                    if (pProperties) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pPropertiesCount)); ++i) {
+                            transform_fromhost_VkTilePropertiesQCOM(
+                                m_state, (VkTilePropertiesQCOM*)(pProperties + i));
+                        }
+                    }
+                }
+                // WARNING PTR CHECK
+                uint64_t cgen_var_5 = (uint64_t)(uintptr_t)pProperties;
+                vkStream->putBe64(cgen_var_5);
+                if (pProperties) {
+                    if (pPropertiesCount) {
+                        for (uint32_t i = 0; i < (uint32_t)(*(pPropertiesCount)); ++i) {
+                            marshal_VkTilePropertiesQCOM(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                         (VkTilePropertiesQCOM*)(pProperties + i));
+                        }
+                    }
+                }
+                vkStream->write(&vkGetFramebufferTilePropertiesQCOM_VkResult_return,
+                                sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetFramebufferTilePropertiesQCOM(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkGetFramebufferTilePropertiesQCOM_VkResult_return, device, framebuffer,
+                        pPropertiesCount, pProperties);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkGetDynamicRenderingTilePropertiesQCOM: {
+                android::base::beginTrace("vkGetDynamicRenderingTilePropertiesQCOM decode");
+                VkDevice device;
+                const VkRenderingInfo* pRenderingInfo;
+                VkTilePropertiesQCOM* pProperties;
+                // Begin non wrapped dispatchable handle unboxing for device;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+                auto unboxed_device = unbox_VkDevice(device);
+                auto vk = dispatch_VkDevice(device);
+                // End manual dispatchable handle unboxing for device;
+                vkReadStream->alloc((void**)&pRenderingInfo, sizeof(const VkRenderingInfo));
+                reservedunmarshal_VkRenderingInfo(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                  (VkRenderingInfo*)(pRenderingInfo),
+                                                  readStreamPtrPtr);
+                // Begin manual dispatchable handle unboxing for pProperties;
+                vkReadStream->unsetHandleMapping();
+                vkReadStream->alloc((void**)&pProperties, sizeof(VkTilePropertiesQCOM));
+                reservedunmarshal_VkTilePropertiesQCOM(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                       (VkTilePropertiesQCOM*)(pProperties),
+                                                       readStreamPtrPtr);
+                if (pRenderingInfo) {
+                    transform_tohost_VkRenderingInfo(m_state, (VkRenderingInfo*)(pRenderingInfo));
+                }
+                if (pProperties) {
+                    transform_tohost_VkTilePropertiesQCOM(m_state,
+                                                          (VkTilePropertiesQCOM*)(pProperties));
+                }
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkGetDynamicRenderingTilePropertiesQCOM 0x%llx 0x%llx "
+                            "0x%llx \n",
+                            ioStream, (unsigned long long)device,
+                            (unsigned long long)pRenderingInfo, (unsigned long long)pProperties);
+                }
+                VkResult vkGetDynamicRenderingTilePropertiesQCOM_VkResult_return = (VkResult)0;
+                vkGetDynamicRenderingTilePropertiesQCOM_VkResult_return =
+                    vk->vkGetDynamicRenderingTilePropertiesQCOM(unboxed_device, pRenderingInfo,
+                                                                pProperties);
+                if ((vkGetDynamicRenderingTilePropertiesQCOM_VkResult_return) ==
+                    VK_ERROR_DEVICE_LOST)
+                    m_state->on_DeviceLost();
+                m_state->on_CheckOutOfMemory(
+                    vkGetDynamicRenderingTilePropertiesQCOM_VkResult_return, opcode, context);
+                vkStream->unsetHandleMapping();
+                if (pProperties) {
+                    transform_fromhost_VkTilePropertiesQCOM(m_state,
+                                                            (VkTilePropertiesQCOM*)(pProperties));
+                }
+                marshal_VkTilePropertiesQCOM(vkStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                             (VkTilePropertiesQCOM*)(pProperties));
+                vkStream->write(&vkGetDynamicRenderingTilePropertiesQCOM_VkResult_return,
+                                sizeof(VkResult));
+                vkStream->commitWrite();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkGetDynamicRenderingTilePropertiesQCOM(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+                        vkGetDynamicRenderingTilePropertiesQCOM_VkResult_return, device,
+                        pRenderingInfo, pProperties);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_SEC_amigo_profiling
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+            case OP_vkCmdSetAttachmentFeedbackLoopEnableEXT: {
+                android::base::beginTrace("vkCmdSetAttachmentFeedbackLoopEnableEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkImageAspectFlags aspectMask;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((VkImageAspectFlags*)&aspectMask, *readStreamPtrPtr,
+                       sizeof(VkImageAspectFlags));
+                *readStreamPtrPtr += sizeof(VkImageAspectFlags);
+                if (m_logCalls) {
+                    fprintf(
+                        stderr,
+                        "stream %p: call vkCmdSetAttachmentFeedbackLoopEnableEXT 0x%llx 0x%llx \n",
+                        ioStream, (unsigned long long)commandBuffer,
+                        (unsigned long long)aspectMask);
+                }
+                vk->vkCmdSetAttachmentFeedbackLoopEnableEXT(unboxed_commandBuffer, aspectMask);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdSetAttachmentFeedbackLoopEnableEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, aspectMask);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
 #ifdef VK_KHR_acceleration_structure
             case OP_vkCreateAccelerationStructureKHR: {
                 android::base::beginTrace("vkCreateAccelerationStructureKHR decode");
@@ -34570,6 +41252,165 @@ size_t VkDecoder::Impl::decode(void* buf, size_t len, IOStream* ioStream,
 #endif
 #ifdef VK_KHR_ray_query
 #endif
+#ifdef VK_EXT_mesh_shader
+            case OP_vkCmdDrawMeshTasksEXT: {
+                android::base::beginTrace("vkCmdDrawMeshTasksEXT decode");
+                VkCommandBuffer commandBuffer;
+                uint32_t groupCountX;
+                uint32_t groupCountY;
+                uint32_t groupCountZ;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdDrawMeshTasksEXT 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer,
+                            (unsigned long long)groupCountX, (unsigned long long)groupCountY,
+                            (unsigned long long)groupCountZ);
+                }
+                vk->vkCmdDrawMeshTasksEXT(unboxed_commandBuffer, groupCountX, groupCountY,
+                                          groupCountZ);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdDrawMeshTasksEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, groupCountX,
+                        groupCountY, groupCountZ);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawMeshTasksIndirectEXT: {
+                android::base::beginTrace("vkCmdDrawMeshTasksIndirectEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                uint32_t drawCount;
+                uint32_t stride;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdDrawMeshTasksIndirectEXT 0x%llx 0x%llx 0x%llx "
+                            "0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer, (unsigned long long)buffer,
+                            (unsigned long long)offset, (unsigned long long)drawCount,
+                            (unsigned long long)stride);
+                }
+                vk->vkCmdDrawMeshTasksIndirectEXT(unboxed_commandBuffer, buffer, offset, drawCount,
+                                                  stride);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdDrawMeshTasksIndirectEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, buffer,
+                        offset, drawCount, stride);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawMeshTasksIndirectCountEXT: {
+                android::base::beginTrace("vkCmdDrawMeshTasksIndirectCountEXT decode");
+                VkCommandBuffer commandBuffer;
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                VkBuffer countBuffer;
+                VkDeviceSize countBufferOffset;
+                uint32_t maxDrawCount;
+                uint32_t stride;
+                // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkCommandBuffer*)&commandBuffer =
+                    (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+                auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+                auto vk = dispatch_VkCommandBuffer(commandBuffer);
+                // End manual dispatchable handle unboxing for commandBuffer;
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                uint64_t cgen_var_2;
+                memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_2));
+                memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (m_logCalls) {
+                    fprintf(stderr,
+                            "stream %p: call vkCmdDrawMeshTasksIndirectCountEXT 0x%llx 0x%llx "
+                            "0x%llx 0x%llx 0x%llx 0x%llx 0x%llx \n",
+                            ioStream, (unsigned long long)commandBuffer, (unsigned long long)buffer,
+                            (unsigned long long)offset, (unsigned long long)countBuffer,
+                            (unsigned long long)countBufferOffset, (unsigned long long)maxDrawCount,
+                            (unsigned long long)stride);
+                }
+                vk->vkCmdDrawMeshTasksIndirectCountEXT(unboxed_commandBuffer, buffer, offset,
+                                                       countBuffer, countBufferOffset, maxDrawCount,
+                                                       stride);
+                vkStream->unsetHandleMapping();
+                vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+                                         (uintptr_t)snapshotTraceBegin);
+                size_t snapshotTraceBytes = vkReadStream->endTrace();
+                if (m_state->snapshotsEnabled()) {
+                    m_state->snapshot()->vkCmdDrawMeshTasksIndirectCountEXT(
+                        snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, buffer,
+                        offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+                }
+                vkReadStream->clearPool();
+                if (queueSubmitWithCommandsEnabled)
+                    seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+                android::base::endTrace();
+                break;
+            }
+#endif
             default: {
                 m_pool.freeAll();
                 return ptr - (unsigned char*)buf;
diff --git a/stream-servers/vulkan/VkDecoder.h b/stream-servers/vulkan/VkDecoder.h
index 963b7dc4..29deda6b 100644
--- a/stream-servers/vulkan/VkDecoder.h
+++ b/stream-servers/vulkan/VkDecoder.h
@@ -15,8 +15,8 @@
 
 // Autogenerated module VkDecoder
 //
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (header) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -73,6 +73,8 @@ class VkDecoder {
 #endif
 #ifdef VK_VERSION_1_2
 #endif
+#ifdef VK_VERSION_1_3
+#endif
 #ifdef VK_KHR_surface
 #endif
 #ifdef VK_KHR_swapchain
@@ -97,6 +99,8 @@ class VkDecoder {
 #endif
 #ifdef VK_KHR_video_decode_queue
 #endif
+#ifdef VK_KHR_video_decode_h264
+#endif
 #ifdef VK_KHR_dynamic_rendering
 #endif
 #ifdef VK_KHR_multiview
@@ -191,6 +195,10 @@ class VkDecoder {
 #endif
 #ifdef VK_KHR_shader_clock
 #endif
+#ifdef VK_KHR_video_decode_h265
+#endif
+#ifdef VK_KHR_global_priority
+#endif
 #ifdef VK_KHR_driver_properties
 #endif
 #ifdef VK_KHR_shader_float_controls
@@ -223,6 +231,8 @@ class VkDecoder {
 #endif
 #ifdef VK_KHR_pipeline_executable_properties
 #endif
+#ifdef VK_KHR_map_memory2
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -235,6 +245,8 @@ class VkDecoder {
 #endif
 #ifdef VK_KHR_synchronization2
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
@@ -245,8 +257,14 @@ class VkDecoder {
 #endif
 #ifdef VK_KHR_format_feature_flags2
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
 #ifdef VK_EXT_debug_report
@@ -287,8 +305,6 @@ class VkDecoder {
 #endif
 #ifdef VK_EXT_video_encode_h265
 #endif
-#ifdef VK_EXT_video_decode_h264
-#endif
 #ifdef VK_AMD_texture_gather_bias_lod
 #endif
 #ifdef VK_AMD_shader_info
@@ -321,6 +337,8 @@ class VkDecoder {
 #endif
 #ifdef VK_EXT_astc_decode_mode
 #endif
+#ifdef VK_EXT_pipeline_robustness
+#endif
 #ifdef VK_EXT_conditional_rendering
 #endif
 #ifdef VK_NV_clip_space_w_scaling
@@ -359,8 +377,6 @@ class VkDecoder {
 #endif
 #ifdef VK_MVK_macos_surface
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -425,8 +441,6 @@ class VkDecoder {
 #endif
 #ifdef VK_AMD_shader_core_properties
 #endif
-#ifdef VK_EXT_video_decode_h265
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 #endif
 #ifdef VK_EXT_vertex_attribute_divisor
@@ -517,6 +531,10 @@ class VkDecoder {
 #endif
 #ifdef VK_EXT_shader_atomic_float2
 #endif
+#ifdef VK_EXT_surface_maintenance1
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+#endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -537,6 +555,8 @@ class VkDecoder {
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+#endif
 #ifdef VK_EXT_private_data
 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
@@ -545,6 +565,16 @@ class VkDecoder {
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+#endif
+#ifdef VK_EXT_metal_objects
+#endif
+#ifdef VK_EXT_descriptor_buffer
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
 #endif
 #ifdef VK_NV_ray_tracing_motion_blur
@@ -557,8 +587,16 @@ class VkDecoder {
 #endif
 #ifdef VK_EXT_image_robustness
 #endif
+#ifdef VK_EXT_image_compression_control
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+#endif
 #ifdef VK_EXT_4444_formats
 #endif
+#ifdef VK_EXT_device_fault
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 #endif
 #ifdef VK_NV_acquire_winrt_display
@@ -571,6 +609,10 @@ class VkDecoder {
 #endif
 #ifdef VK_EXT_physical_device_drm
 #endif
+#ifdef VK_EXT_device_address_binding_report
+#endif
+#ifdef VK_EXT_depth_clip_control
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 #endif
 #ifdef VK_FUCHSIA_external_memory
@@ -585,27 +627,107 @@ class VkDecoder {
 #endif
 #ifdef VK_NV_external_memory_rdma
 #endif
+#ifdef VK_EXT_pipeline_properties
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 #endif
 #ifdef VK_QNX_screen_surface
 #endif
 #ifdef VK_EXT_color_write_enable
 #endif
+#ifdef VK_EXT_primitives_generated_query
+#endif
 #ifdef VK_GOOGLE_gfxstream
 #endif
 #ifdef VK_EXT_global_priority_query
 #endif
+#ifdef VK_EXT_image_view_min_lod
+#endif
 #ifdef VK_EXT_multi_draw
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+#endif
+#ifdef VK_EXT_shader_tile_image
+#endif
+#ifdef VK_EXT_opacity_micromap
+#endif
+#ifdef VK_NV_displacement_micromap
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+#endif
 #ifdef VK_EXT_border_color_swizzle
 #endif
 #ifdef VK_EXT_pageable_device_local_memory
 #endif
+#ifdef VK_ARM_shader_core_properties
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+#endif
+#ifdef VK_NV_copy_memory_indirect
+#endif
+#ifdef VK_NV_memory_decompression
+#endif
+#ifdef VK_NV_linear_color_attachment
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+#endif
+#ifdef VK_QCOM_image_processing
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+#endif
+#ifdef VK_EXT_shader_module_identifier
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+#endif
+#ifdef VK_EXT_legacy_dithering
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+#endif
+#ifdef VK_EXT_shader_object
+#endif
+#ifdef VK_QCOM_tile_properties
+#endif
+#ifdef VK_SEC_amigo_profiling
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+#endif
 #ifdef VK_KHR_acceleration_structure
 #endif
 #ifdef VK_KHR_ray_tracing_pipeline
 #endif
 #ifdef VK_KHR_ray_query
 #endif
+#ifdef VK_EXT_mesh_shader
+#endif
diff --git a/stream-servers/vulkan/VkDecoderGlobalState.cpp b/stream-servers/vulkan/VkDecoderGlobalState.cpp
index 1922dbef..da07609c 100644
--- a/stream-servers/vulkan/VkDecoderGlobalState.cpp
+++ b/stream-servers/vulkan/VkDecoderGlobalState.cpp
@@ -1622,8 +1622,64 @@ class VkDecoderGlobalState::Impl {
         destroyImageLocked(device, deviceDispatch, image, pAllocator);
     }
 
-    VkResult on_vkBindImageMemory(android::base::BumpPool* pool, VkDevice boxed_device,
-                                  VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+    VkResult performBindImageMemoryDeferredAhb(android::base::BumpPool* pool,
+                                               VkDevice boxed_device,
+                                               const VkBindImageMemoryInfo* bimi) {
+        auto device = unbox_VkDevice(boxed_device);
+        auto vk = dispatch_VkDevice(boxed_device);
+
+        auto original_underlying_image = bimi->image;
+        auto original_boxed_image = unboxed_to_boxed_non_dispatchable_VkImage(original_underlying_image);
+
+        VkImageCreateInfo ici = {};
+        {
+            std::lock_guard<std::recursive_mutex> lock(mLock);
+
+            auto* imageInfo = android::base::find(mImageInfo, original_underlying_image);
+            if (!imageInfo) {
+                ERR("Image for deferred AHB bind does not exist.");
+                return VK_ERROR_OUT_OF_HOST_MEMORY;
+            }
+
+            ici = imageInfo->imageCreateInfoShallow;
+        }
+
+        ici.pNext = vk_find_struct<VkNativeBufferANDROID>(bimi);
+        if (!ici.pNext) {
+            GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
+                << "Missing VkNativeBufferANDROID for deferred AHB bind.";
+        }
+
+        VkImage boxed_replacement_image = VK_NULL_HANDLE;
+        VkResult result = on_vkCreateImage(pool, boxed_device, &ici, nullptr, &boxed_replacement_image);
+        if (result != VK_SUCCESS) {
+            ERR("Failed to create image for deferred AHB bind.");
+            return VK_ERROR_OUT_OF_HOST_MEMORY;
+        }
+
+        on_vkDestroyImage(pool, boxed_device, original_underlying_image, nullptr);
+
+        {
+            std::lock_guard<std::recursive_mutex> lock(mLock);
+
+            auto underlying_replacement_image = unbox_VkImage(boxed_replacement_image);
+            delete_VkImage(boxed_replacement_image);
+            set_boxed_non_dispatchable_VkImage(original_boxed_image, underlying_replacement_image);
+        }
+
+        return VK_SUCCESS;
+    }
+
+    VkResult performBindImageMemory(android::base::BumpPool* pool, VkDevice boxed_device,
+                                    const VkBindImageMemoryInfo* bimi) {
+        auto image = bimi->image;
+        auto memory = bimi->memory;
+        auto memoryOffset = bimi->memoryOffset;
+
+        const auto* anb = vk_find_struct<VkNativeBufferANDROID>(bimi);
+        if (memory == VK_NULL_HANDLE && anb != nullptr) {
+            return performBindImageMemoryDeferredAhb(pool, boxed_device, bimi);
+        }
         auto device = unbox_VkDevice(boxed_device);
         auto vk = dispatch_VkDevice(boxed_device);
 
@@ -1658,6 +1714,18 @@ class VkDecoderGlobalState::Impl {
         return cmpInfo.bindCompressedMipmapsMemory(vk, memory, memoryOffset);
     }
 
+    VkResult on_vkBindImageMemory(android::base::BumpPool* pool, VkDevice boxed_device,
+                                  VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+        const VkBindImageMemoryInfo bimi = {
+            .sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
+            .pNext = nullptr,
+            .image = image,
+            .memory = memory,
+            .memoryOffset = memoryOffset,
+        };
+        return performBindImageMemory(pool, boxed_device, &bimi);
+    }
+
     VkResult on_vkBindImageMemory2(android::base::BumpPool* pool, VkDevice boxed_device,
                                    uint32_t bindInfoCount,
                                    const VkBindImageMemoryInfo* pBindInfos) {
@@ -1672,6 +1740,12 @@ class VkDecoderGlobalState::Impl {
             auto* imageInfo = android::base::find(mImageInfo, pBindInfos[i].image);
             if (!imageInfo) return VK_ERROR_UNKNOWN;
 
+            const auto* anb = vk_find_struct<VkNativeBufferANDROID>(&pBindInfos[i]);
+            if (anb != nullptr) {
+                needEmulation = true;
+                break;
+            }
+
             if (deviceInfo->needEmulatedDecompression(imageInfo->cmpInfo)) {
                 needEmulation = true;
                 break;
@@ -1681,8 +1755,7 @@ class VkDecoderGlobalState::Impl {
         if (needEmulation) {
             VkResult result;
             for (uint32_t i = 0; i < bindInfoCount; i++) {
-                result = on_vkBindImageMemory(pool, boxed_device, pBindInfos[i].image,
-                                              pBindInfos[i].memory, pBindInfos[i].memoryOffset);
+                result = performBindImageMemory(pool, boxed_device, &pBindInfos[i]);
 
                 if (result != VK_SUCCESS) return result;
             }
@@ -4072,6 +4145,34 @@ class VkDecoderGlobalState::Impl {
                                               info->data.data());
     }
 
+    void on_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+        android::base::BumpPool* pool, VkDevice boxed_device, VkDescriptorSet descriptorSet,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+        uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
+        const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
+        const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
+        const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
+        const uint8_t* pInlineUniformBlockData) {
+        auto device = unbox_VkDevice(boxed_device);
+        auto vk = dispatch_VkDevice(boxed_device);
+
+        std::lock_guard<std::recursive_mutex> lock(mLock);
+        auto* info = android::base::find(mDescriptorUpdateTemplateInfo, descriptorUpdateTemplate);
+        if (!info) return;
+
+        memcpy(info->data.data() + info->imageInfoStart, pImageInfos,
+               imageInfoCount * sizeof(VkDescriptorImageInfo));
+        memcpy(info->data.data() + info->bufferInfoStart, pBufferInfos,
+               bufferInfoCount * sizeof(VkDescriptorBufferInfo));
+        memcpy(info->data.data() + info->bufferViewStart, pBufferViews,
+               bufferViewCount * sizeof(VkBufferView));
+        memcpy(info->data.data() + info->inlineUniformBlockStart, pInlineUniformBlockData,
+               inlineUniformBlockCount);
+
+        vk->vkUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate,
+                                              info->data.data());
+    }
+
     void hostSyncCommandBuffer(const char* tag, VkCommandBuffer boxed_commandBuffer,
                                uint32_t needHostSync, uint32_t sequenceNumber) {
         auto nextDeadline = []() {
@@ -5779,6 +5880,7 @@ class VkDecoderGlobalState::Impl {
         size_t imageInfoStart;
         size_t bufferInfoStart;
         size_t bufferViewStart;
+        size_t inlineUniformBlockStart;
     };
 
     DescriptorUpdateTemplateInfo calcLinearizedDescriptorUpdateTemplateInfo(
@@ -5789,6 +5891,7 @@ class VkDecoderGlobalState::Impl {
         size_t numImageInfos = 0;
         size_t numBufferInfos = 0;
         size_t numBufferViews = 0;
+        size_t numInlineUniformBlocks = 0;
 
         for (uint32_t i = 0; i < pCreateInfo->descriptorUpdateEntryCount; ++i) {
             const auto& entry = pCreateInfo->pDescriptorUpdateEntries[i];
@@ -5800,6 +5903,8 @@ class VkDecoderGlobalState::Impl {
                 numBufferInfos += count;
             } else if (isDescriptorTypeBufferView(type)) {
                 numBufferViews += count;
+            } else if (type == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) {
+                numInlineUniformBlocks += count;
             } else {
                 GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
                     << "unknown descriptor type 0x" << std::hex << type;
@@ -5809,15 +5914,19 @@ class VkDecoderGlobalState::Impl {
         size_t imageInfoBytes = numImageInfos * sizeof(VkDescriptorImageInfo);
         size_t bufferInfoBytes = numBufferInfos * sizeof(VkDescriptorBufferInfo);
         size_t bufferViewBytes = numBufferViews * sizeof(VkBufferView);
+        size_t inlineUniformBlockBytes = numInlineUniformBlocks;
 
-        res.data.resize(imageInfoBytes + bufferInfoBytes + bufferViewBytes);
+        res.data.resize(imageInfoBytes + bufferInfoBytes + bufferViewBytes +
+                        inlineUniformBlockBytes);
         res.imageInfoStart = 0;
         res.bufferInfoStart = imageInfoBytes;
         res.bufferViewStart = imageInfoBytes + bufferInfoBytes;
+        res.inlineUniformBlockStart = imageInfoBytes + bufferInfoBytes + bufferViewBytes;
 
         size_t imageInfoCount = 0;
         size_t bufferInfoCount = 0;
         size_t bufferViewCount = 0;
+        size_t inlineUniformBlockCount = 0;
 
         for (uint32_t i = 0; i < pCreateInfo->descriptorUpdateEntryCount; ++i) {
             const auto& entry = pCreateInfo->pDescriptorUpdateEntries[i];
@@ -5839,6 +5948,10 @@ class VkDecoderGlobalState::Impl {
                 entryForHost.offset = res.bufferViewStart + bufferViewCount * sizeof(VkBufferView);
                 entryForHost.stride = sizeof(VkBufferView);
                 ++bufferViewCount;
+            } else if (type == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) {
+                entryForHost.offset = res.inlineUniformBlockStart + inlineUniformBlockCount;
+                entryForHost.stride = 0;
+                inlineUniformBlockCount += entryForHost.descriptorCount;
             } else {
                 GFXSTREAM_ABORT(FatalError(ABORT_REASON_OTHER))
                     << "unknown descriptor type 0x" << std::hex << type;
@@ -5969,6 +6082,7 @@ class VkDecoderGlobalState::Impl {
 
     struct ImageInfo {
         VkDevice device;
+        VkImageCreateInfo imageCreateInfoShallow;
         std::shared_ptr<AndroidNativeBufferInfo> anbInfo;
         CompressedImageInfo cmpInfo;
     };
@@ -7012,6 +7126,21 @@ void VkDecoderGlobalState::on_vkUpdateDescriptorSetWithTemplateSizedGOOGLE(
         pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews);
 }
 
+void VkDecoderGlobalState::on_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+    android::base::BumpPool* pool, VkDevice boxed_device, VkDescriptorSet descriptorSet,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+    uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
+    const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
+    const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
+    const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
+    const uint8_t* pInlineUniformBlockData) {
+    mImpl->on_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+        pool, boxed_device, descriptorSet, descriptorUpdateTemplate, imageInfoCount,
+        bufferInfoCount, bufferViewCount, inlineUniformBlockCount, pImageInfoEntryIndices,
+        pBufferInfoEntryIndices, pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews,
+        pInlineUniformBlockData);
+}
+
 VkResult VkDecoderGlobalState::on_vkBeginCommandBuffer(android::base::BumpPool* pool,
                                                        VkCommandBuffer commandBuffer,
                                                        const VkCommandBufferBeginInfo* pBeginInfo,
diff --git a/stream-servers/vulkan/VkDecoderGlobalState.h b/stream-servers/vulkan/VkDecoderGlobalState.h
index b74f1ab7..f49285f1 100644
--- a/stream-servers/vulkan/VkDecoderGlobalState.h
+++ b/stream-servers/vulkan/VkDecoderGlobalState.h
@@ -511,6 +511,15 @@ class VkDecoderGlobalState {
         const VkDescriptorImageInfo* pImageInfos, const VkDescriptorBufferInfo* pBufferInfos,
         const VkBufferView* pBufferViews);
 
+    void on_vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+        android::base::BumpPool* pool, VkDevice boxed_device, VkDescriptorSet descriptorSet,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+        uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
+        const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
+        const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
+        const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
+        const uint8_t* pInlineUniformBlockData);
+
     VkResult on_vkBeginCommandBuffer(android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
                                      const VkCommandBufferBeginInfo* pBeginInfo,
                                      const VkDecoderContext& context);
diff --git a/stream-servers/vulkan/VkDecoderSnapshot.cpp b/stream-servers/vulkan/VkDecoderSnapshot.cpp
index 99034b48..6aa323da 100644
--- a/stream-servers/vulkan/VkDecoderSnapshot.cpp
+++ b/stream-servers/vulkan/VkDecoderSnapshot.cpp
@@ -15,8 +15,8 @@
 
 // Autogenerated module VkDecoderSnapshot
 //
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (impl) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -1565,6 +1565,211 @@ class VkDecoderSnapshot::Impl {
         // TODO: Implement
     }
 #endif
+#ifdef VK_VERSION_1_3
+    void vkGetPhysicalDeviceToolProperties(const uint8_t* snapshotTraceBegin,
+                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                           VkResult input_result, VkPhysicalDevice physicalDevice,
+                                           uint32_t* pToolCount,
+                                           VkPhysicalDeviceToolProperties* pToolProperties) {
+        // TODO: Implement
+    }
+    void vkCreatePrivateDataSlot(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkResult input_result,
+                                 VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
+                                 const VkAllocationCallbacks* pAllocator,
+                                 VkPrivateDataSlot* pPrivateDataSlot) {
+        // TODO: Implement
+    }
+    void vkDestroyPrivateDataSlot(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                  android::base::BumpPool* pool, VkDevice device,
+                                  VkPrivateDataSlot privateDataSlot,
+                                  const VkAllocationCallbacks* pAllocator) {
+        // TODO: Implement
+    }
+    void vkSetPrivateData(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                          android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                          VkObjectType objectType, uint64_t objectHandle,
+                          VkPrivateDataSlot privateDataSlot, uint64_t data) {
+        // TODO: Implement
+    }
+    void vkGetPrivateData(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                          android::base::BumpPool* pool, VkDevice device, VkObjectType objectType,
+                          uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
+                          uint64_t* pData) {
+        // TODO: Implement
+    }
+    void vkCmdSetEvent2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                        android::base::BumpPool* pool, VkCommandBuffer commandBuffer, VkEvent event,
+                        const VkDependencyInfo* pDependencyInfo) {
+        // TODO: Implement
+    }
+    void vkCmdResetEvent2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                          android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                          VkEvent event, VkPipelineStageFlags2 stageMask) {
+        // TODO: Implement
+    }
+    void vkCmdWaitEvents2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                          android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                          uint32_t eventCount, const VkEvent* pEvents,
+                          const VkDependencyInfo* pDependencyInfos) {
+        // TODO: Implement
+    }
+    void vkCmdPipelineBarrier2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                               android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                               const VkDependencyInfo* pDependencyInfo) {
+        // TODO: Implement
+    }
+    void vkCmdWriteTimestamp2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                              android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                              VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) {
+        // TODO: Implement
+    }
+    void vkQueueSubmit2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                        android::base::BumpPool* pool, VkResult input_result, VkQueue queue,
+                        uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) {
+        // TODO: Implement
+    }
+    void vkCmdCopyBuffer2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                          android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                          const VkCopyBufferInfo2* pCopyBufferInfo) {
+        // TODO: Implement
+    }
+    void vkCmdCopyImage2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                         android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                         const VkCopyImageInfo2* pCopyImageInfo) {
+        // TODO: Implement
+    }
+    void vkCmdCopyBufferToImage2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                 const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
+        // TODO: Implement
+    }
+    void vkCmdCopyImageToBuffer2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                 const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
+        // TODO: Implement
+    }
+    void vkCmdBlitImage2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                         android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                         const VkBlitImageInfo2* pBlitImageInfo) {
+        // TODO: Implement
+    }
+    void vkCmdResolveImage2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                            android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                            const VkResolveImageInfo2* pResolveImageInfo) {
+        // TODO: Implement
+    }
+    void vkCmdBeginRendering(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                             android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                             const VkRenderingInfo* pRenderingInfo) {
+        // TODO: Implement
+    }
+    void vkCmdEndRendering(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                           android::base::BumpPool* pool, VkCommandBuffer commandBuffer) {
+        // TODO: Implement
+    }
+    void vkCmdSetCullMode(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                          android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                          VkCullModeFlags cullMode) {
+        // TODO: Implement
+    }
+    void vkCmdSetFrontFace(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                           android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                           VkFrontFace frontFace) {
+        // TODO: Implement
+    }
+    void vkCmdSetPrimitiveTopology(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   VkPrimitiveTopology primitiveTopology) {
+        // TODO: Implement
+    }
+    void vkCmdSetViewportWithCount(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   uint32_t viewportCount, const VkViewport* pViewports) {
+        // TODO: Implement
+    }
+    void vkCmdSetScissorWithCount(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                  android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                  uint32_t scissorCount, const VkRect2D* pScissors) {
+        // TODO: Implement
+    }
+    void vkCmdBindVertexBuffers2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                 uint32_t firstBinding, uint32_t bindingCount,
+                                 const VkBuffer* pBuffers, const VkDeviceSize* pOffsets,
+                                 const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) {
+        // TODO: Implement
+    }
+    void vkCmdSetDepthTestEnable(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                 VkBool32 depthTestEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetDepthWriteEnable(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                  android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                  VkBool32 depthWriteEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetDepthCompareOp(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                VkCompareOp depthCompareOp) {
+        // TODO: Implement
+    }
+    void vkCmdSetDepthBoundsTestEnable(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                       VkBool32 depthBoundsTestEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetStencilTestEnable(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   VkBool32 stencilTestEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetStencilOp(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                           android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                           VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp,
+                           VkStencilOp depthFailOp, VkCompareOp compareOp) {
+        // TODO: Implement
+    }
+    void vkCmdSetRasterizerDiscardEnable(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer,
+                                         VkBool32 rasterizerDiscardEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetDepthBiasEnable(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                 VkBool32 depthBiasEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetPrimitiveRestartEnable(const uint8_t* snapshotTraceBegin,
+                                        size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                        VkCommandBuffer commandBuffer,
+                                        VkBool32 primitiveRestartEnable) {
+        // TODO: Implement
+    }
+    void vkGetDeviceBufferMemoryRequirements(const uint8_t* snapshotTraceBegin,
+                                             size_t snapshotTraceBytes,
+                                             android::base::BumpPool* pool, VkDevice device,
+                                             const VkDeviceBufferMemoryRequirements* pInfo,
+                                             VkMemoryRequirements2* pMemoryRequirements) {
+        // TODO: Implement
+    }
+    void vkGetDeviceImageMemoryRequirements(const uint8_t* snapshotTraceBegin,
+                                            size_t snapshotTraceBytes,
+                                            android::base::BumpPool* pool, VkDevice device,
+                                            const VkDeviceImageMemoryRequirements* pInfo,
+                                            VkMemoryRequirements2* pMemoryRequirements) {
+        // TODO: Implement
+    }
+    void vkGetDeviceImageSparseMemoryRequirements(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
+        uint32_t* pSparseMemoryRequirementCount,
+        VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
+        // TODO: Implement
+    }
+#endif
 #ifdef VK_KHR_surface
     void vkDestroySurfaceKHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkInstance instance,
@@ -1818,7 +2023,7 @@ class VkDecoderSnapshot::Impl {
     void vkGetPhysicalDeviceVideoCapabilitiesKHR(
         const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
         VkResult input_result, VkPhysicalDevice physicalDevice,
-        const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) {
+        const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) {
         // TODO: Implement
     }
     void vkGetPhysicalDeviceVideoFormatPropertiesKHR(
@@ -1844,15 +2049,15 @@ class VkDecoderSnapshot::Impl {
     void vkGetVideoSessionMemoryRequirementsKHR(
         const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
         VkResult input_result, VkDevice device, VkVideoSessionKHR videoSession,
-        uint32_t* pVideoSessionMemoryRequirementsCount,
-        VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements) {
+        uint32_t* pMemoryRequirementsCount,
+        VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) {
         // TODO: Implement
     }
-    void vkBindVideoSessionMemoryKHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                                     android::base::BumpPool* pool, VkResult input_result,
-                                     VkDevice device, VkVideoSessionKHR videoSession,
-                                     uint32_t videoSessionBindMemoryCount,
-                                     const VkVideoBindMemoryKHR* pVideoSessionBindMemories) {
+    void vkBindVideoSessionMemoryKHR(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkDevice device, VkVideoSessionKHR videoSession,
+        uint32_t bindSessionMemoryInfoCount,
+        const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) {
         // TODO: Implement
     }
     void vkCreateVideoSessionParametersKHR(const uint8_t* snapshotTraceBegin,
@@ -1895,14 +2100,16 @@ class VkDecoderSnapshot::Impl {
 #ifdef VK_KHR_video_decode_queue
     void vkCmdDecodeVideoKHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                             const VkVideoDecodeInfoKHR* pFrameInfo) {
+                             const VkVideoDecodeInfoKHR* pDecodeInfo) {
         // TODO: Implement
     }
 #endif
+#ifdef VK_KHR_video_decode_h264
+#endif
 #ifdef VK_KHR_dynamic_rendering
     void vkCmdBeginRenderingKHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                                const VkRenderingInfoKHR* pRenderingInfo) {
+                                const VkRenderingInfo* pRenderingInfo) {
         // TODO: Implement
     }
     void vkCmdEndRenderingKHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
@@ -2411,6 +2618,10 @@ class VkDecoderSnapshot::Impl {
 #endif
 #ifdef VK_KHR_shader_clock
 #endif
+#ifdef VK_KHR_video_decode_h265
+#endif
+#ifdef VK_KHR_global_priority
+#endif
 #ifdef VK_KHR_driver_properties
 #endif
 #ifdef VK_KHR_shader_float_controls
@@ -2543,6 +2754,18 @@ class VkDecoderSnapshot::Impl {
         // TODO: Implement
     }
 #endif
+#ifdef VK_KHR_map_memory2
+    void vkMapMemory2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                         android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                         const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData) {
+        // TODO: Implement
+    }
+    void vkUnmapMemory2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                           android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                           const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo) {
+        // TODO: Implement
+    }
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -2561,39 +2784,39 @@ class VkDecoderSnapshot::Impl {
 #ifdef VK_KHR_synchronization2
     void vkCmdSetEvent2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                            android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                           VkEvent event, const VkDependencyInfoKHR* pDependencyInfo) {
+                           VkEvent event, const VkDependencyInfo* pDependencyInfo) {
         // TODO: Implement
     }
     void vkCmdResetEvent2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                             VkEvent event, VkPipelineStageFlags2KHR stageMask) {
+                             VkEvent event, VkPipelineStageFlags2 stageMask) {
         // TODO: Implement
     }
     void vkCmdWaitEvents2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
                              uint32_t eventCount, const VkEvent* pEvents,
-                             const VkDependencyInfoKHR* pDependencyInfos) {
+                             const VkDependencyInfo* pDependencyInfos) {
         // TODO: Implement
     }
     void vkCmdPipelineBarrier2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                                  const VkDependencyInfoKHR* pDependencyInfo) {
+                                  const VkDependencyInfo* pDependencyInfo) {
         // TODO: Implement
     }
     void vkCmdWriteTimestamp2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                  android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                                 VkPipelineStageFlags2KHR stage, VkQueryPool queryPool,
+                                 VkPipelineStageFlags2 stage, VkQueryPool queryPool,
                                  uint32_t query) {
         // TODO: Implement
     }
     void vkQueueSubmit2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                            android::base::BumpPool* pool, VkResult input_result, VkQueue queue,
-                           uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits, VkFence fence) {
+                           uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) {
         // TODO: Implement
     }
     void vkCmdWriteBufferMarker2AMD(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                                    VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer,
+                                    VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
                                     VkDeviceSize dstOffset, uint32_t marker) {
         // TODO: Implement
     }
@@ -2604,6 +2827,8 @@ class VkDecoderSnapshot::Impl {
         // TODO: Implement
     }
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
@@ -2613,60 +2838,71 @@ class VkDecoderSnapshot::Impl {
 #ifdef VK_KHR_copy_commands2
     void vkCmdCopyBuffer2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                             const VkCopyBufferInfo2KHR* pCopyBufferInfo) {
+                             const VkCopyBufferInfo2* pCopyBufferInfo) {
         // TODO: Implement
     }
     void vkCmdCopyImage2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                             android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                            const VkCopyImageInfo2KHR* pCopyImageInfo) {
+                            const VkCopyImageInfo2* pCopyImageInfo) {
         // TODO: Implement
     }
     void vkCmdCopyBufferToImage2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                                    const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo) {
+                                    const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
         // TODO: Implement
     }
     void vkCmdCopyImageToBuffer2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                                    const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo) {
+                                    const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
         // TODO: Implement
     }
     void vkCmdBlitImage2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                             android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                            const VkBlitImageInfo2KHR* pBlitImageInfo) {
+                            const VkBlitImageInfo2* pBlitImageInfo) {
         // TODO: Implement
     }
     void vkCmdResolveImage2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                               const VkResolveImageInfo2KHR* pResolveImageInfo) {
+                               const VkResolveImageInfo2* pResolveImageInfo) {
         // TODO: Implement
     }
 #endif
 #ifdef VK_KHR_format_feature_flags2
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+    void vkCmdTraceRaysIndirect2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                    android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                    VkDeviceAddress indirectDeviceAddress) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
     void vkGetDeviceBufferMemoryRequirementsKHR(const uint8_t* snapshotTraceBegin,
                                                 size_t snapshotTraceBytes,
                                                 android::base::BumpPool* pool, VkDevice device,
-                                                const VkDeviceBufferMemoryRequirementsKHR* pInfo,
+                                                const VkDeviceBufferMemoryRequirements* pInfo,
                                                 VkMemoryRequirements2* pMemoryRequirements) {
         // TODO: Implement
     }
     void vkGetDeviceImageMemoryRequirementsKHR(const uint8_t* snapshotTraceBegin,
                                                size_t snapshotTraceBytes,
                                                android::base::BumpPool* pool, VkDevice device,
-                                               const VkDeviceImageMemoryRequirementsKHR* pInfo,
+                                               const VkDeviceImageMemoryRequirements* pInfo,
                                                VkMemoryRequirements2* pMemoryRequirements) {
         // TODO: Implement
     }
     void vkGetDeviceImageSparseMemoryRequirementsKHR(
         const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
-        VkDevice device, const VkDeviceImageMemoryRequirementsKHR* pInfo,
+        VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
         uint32_t* pSparseMemoryRequirementCount,
         VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
         // TODO: Implement
     }
 #endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+#endif
 #ifdef VK_ANDROID_native_buffer
     void vkGetSwapchainGrallocUsageANDROID(const uint8_t* snapshotTraceBegin,
                                            size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -2688,6 +2924,13 @@ class VkDecoderSnapshot::Impl {
                                           int* pNativeFenceFd) {
         // TODO: Implement
     }
+    void vkGetSwapchainGrallocUsage2ANDROID(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
+        VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
+        uint64_t* grallocProducerUsage) {
+        // TODO: Implement
+    }
 #endif
 #ifdef VK_EXT_debug_report
     void vkCreateDebugReportCallbackEXT(const uint8_t* snapshotTraceBegin,
@@ -2880,8 +3123,6 @@ class VkDecoderSnapshot::Impl {
 #endif
 #ifdef VK_EXT_video_encode_h265
 #endif
-#ifdef VK_EXT_video_decode_h264
-#endif
 #ifdef VK_AMD_texture_gather_bias_lod
 #endif
 #ifdef VK_AMD_shader_info
@@ -2947,6 +3188,8 @@ class VkDecoderSnapshot::Impl {
 #endif
 #ifdef VK_EXT_astc_decode_mode
 #endif
+#ifdef VK_EXT_pipeline_robustness
+#endif
 #ifdef VK_EXT_conditional_rendering
     void vkCmdBeginConditionalRenderingEXT(
         const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -3058,6 +3301,18 @@ class VkDecoderSnapshot::Impl {
                                      const VkRect2D* pDiscardRectangles) {
         // TODO: Implement
     }
+    void vkCmdSetDiscardRectangleEnableEXT(const uint8_t* snapshotTraceBegin,
+                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                           VkCommandBuffer commandBuffer,
+                                           VkBool32 discardRectangleEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetDiscardRectangleModeEXT(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer,
+                                         VkDiscardRectangleModeEXT discardRectangleMode) {
+        // TODO: Implement
+    }
 #endif
 #ifdef VK_EXT_conservative_rasterization
 #endif
@@ -3090,35 +3345,6 @@ class VkDecoderSnapshot::Impl {
         // TODO: Implement
     }
 #endif
-#ifdef VK_MVK_moltenvk
-    void vkGetMTLDeviceMVK(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                           android::base::BumpPool* pool, VkPhysicalDevice physicalDevice,
-                           void** pMTLDevice) {
-        // TODO: Implement
-    }
-    void vkSetMTLTextureMVK(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                            android::base::BumpPool* pool, VkResult input_result, VkImage image,
-                            void* mtlTexture) {
-        // TODO: Implement
-    }
-    void vkGetMTLTextureMVK(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                            android::base::BumpPool* pool, VkImage image, void** pMTLTexture) {
-        // TODO: Implement
-    }
-    void vkGetMTLBufferMVK(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                           android::base::BumpPool* pool, VkBuffer buffer, void** pMTLBuffer) {
-        // TODO: Implement
-    }
-    void vkUseIOSurfaceMVK(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                           android::base::BumpPool* pool, VkResult input_result, VkImage image,
-                           void* ioSurface) {
-        // TODO: Implement
-    }
-    void vkGetIOSurfaceMVK(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                           android::base::BumpPool* pool, VkImage image, void** pIOSurface) {
-        // TODO: Implement
-    }
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -3490,8 +3716,6 @@ class VkDecoderSnapshot::Impl {
 #endif
 #ifdef VK_AMD_shader_core_properties
 #endif
-#ifdef VK_EXT_video_decode_h265
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 #endif
 #ifdef VK_EXT_vertex_attribute_divisor
@@ -3530,6 +3754,14 @@ class VkDecoderSnapshot::Impl {
 #ifdef VK_NV_shader_image_footprint
 #endif
 #ifdef VK_NV_scissor_exclusive
+    void vkCmdSetExclusiveScissorEnableNV(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          uint32_t firstExclusiveScissor,
+                                          uint32_t exclusiveScissorCount,
+                                          const VkBool32* pExclusiveScissorEnables) {
+        // TODO: Implement
+    }
     void vkCmdSetExclusiveScissorNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
                                     uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount,
@@ -3673,7 +3905,7 @@ class VkDecoderSnapshot::Impl {
                                               size_t snapshotTraceBytes,
                                               android::base::BumpPool* pool, VkResult input_result,
                                               VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
-                                              VkPhysicalDeviceToolPropertiesEXT* pToolProperties) {
+                                              VkPhysicalDeviceToolProperties* pToolProperties) {
         // TODO: Implement
     }
 #endif
@@ -3826,6 +4058,16 @@ class VkDecoderSnapshot::Impl {
 #endif
 #ifdef VK_EXT_shader_atomic_float2
 #endif
+#ifdef VK_EXT_surface_maintenance1
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+    void vkReleaseSwapchainImagesEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                     android::base::BumpPool* pool, VkResult input_result,
+                                     VkDevice device,
+                                     const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) {
+        // TODO: Implement
+    }
+#endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -3913,31 +4155,32 @@ class VkDecoderSnapshot::Impl {
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+#endif
 #ifdef VK_EXT_private_data
     void vkCreatePrivateDataSlotEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                     android::base::BumpPool* pool, VkResult input_result,
-                                    VkDevice device,
-                                    const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
+                                    VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
                                     const VkAllocationCallbacks* pAllocator,
-                                    VkPrivateDataSlotEXT* pPrivateDataSlot) {
+                                    VkPrivateDataSlot* pPrivateDataSlot) {
         // TODO: Implement
     }
     void vkDestroyPrivateDataSlotEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                      android::base::BumpPool* pool, VkDevice device,
-                                     VkPrivateDataSlotEXT privateDataSlot,
+                                     VkPrivateDataSlot privateDataSlot,
                                      const VkAllocationCallbacks* pAllocator) {
         // TODO: Implement
     }
     void vkSetPrivateDataEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkResult input_result, VkDevice device,
                              VkObjectType objectType, uint64_t objectHandle,
-                             VkPrivateDataSlotEXT privateDataSlot, uint64_t data) {
+                             VkPrivateDataSlot privateDataSlot, uint64_t data) {
         // TODO: Implement
     }
     void vkGetPrivateDataEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkDevice device,
                              VkObjectType objectType, uint64_t objectHandle,
-                             VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData) {
+                             VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
         // TODO: Implement
     }
 #endif
@@ -3947,6 +4190,93 @@ class VkDecoderSnapshot::Impl {
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+#endif
+#ifdef VK_EXT_metal_objects
+    void vkExportMetalObjectsEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkDevice device,
+                                 VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+    void vkGetDescriptorSetLayoutSizeEXT(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkDevice device, VkDescriptorSetLayout layout,
+                                         VkDeviceSize* pLayoutSizeInBytes) {
+        // TODO: Implement
+    }
+    void vkGetDescriptorSetLayoutBindingOffsetEXT(const uint8_t* snapshotTraceBegin,
+                                                  size_t snapshotTraceBytes,
+                                                  android::base::BumpPool* pool, VkDevice device,
+                                                  VkDescriptorSetLayout layout, uint32_t binding,
+                                                  VkDeviceSize* pOffset) {
+        // TODO: Implement
+    }
+    void vkGetDescriptorEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                            android::base::BumpPool* pool, VkDevice device,
+                            const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize,
+                            void* pDescriptor) {
+        // TODO: Implement
+    }
+    void vkCmdBindDescriptorBuffersEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                       uint32_t bufferCount,
+                                       const VkDescriptorBufferBindingInfoEXT* pBindingInfos) {
+        // TODO: Implement
+    }
+    void vkCmdSetDescriptorBufferOffsetsEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+        VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount,
+        const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) {
+        // TODO: Implement
+    }
+    void vkCmdBindDescriptorBufferEmbeddedSamplersEXT(const uint8_t* snapshotTraceBegin,
+                                                      size_t snapshotTraceBytes,
+                                                      android::base::BumpPool* pool,
+                                                      VkCommandBuffer commandBuffer,
+                                                      VkPipelineBindPoint pipelineBindPoint,
+                                                      VkPipelineLayout layout, uint32_t set) {
+        // TODO: Implement
+    }
+    void vkGetBufferOpaqueCaptureDescriptorDataEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo,
+        void* pData) {
+        // TODO: Implement
+    }
+    void vkGetImageOpaqueCaptureDescriptorDataEXT(const uint8_t* snapshotTraceBegin,
+                                                  size_t snapshotTraceBytes,
+                                                  android::base::BumpPool* pool,
+                                                  VkResult input_result, VkDevice device,
+                                                  const VkImageCaptureDescriptorDataInfoEXT* pInfo,
+                                                  void* pData) {
+        // TODO: Implement
+    }
+    void vkGetImageViewOpaqueCaptureDescriptorDataEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkDevice device,
+        const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
+        // TODO: Implement
+    }
+    void vkGetSamplerOpaqueCaptureDescriptorDataEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo,
+        void* pData) {
+        // TODO: Implement
+    }
+    void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkDevice device,
+        const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
     void vkCmdSetFragmentShadingRateEnumNV(
         const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -3965,8 +4295,29 @@ class VkDecoderSnapshot::Impl {
 #endif
 #ifdef VK_EXT_image_robustness
 #endif
+#ifdef VK_EXT_image_compression_control
+    void vkGetImageSubresourceLayout2EXT(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkDevice device, VkImage image,
+                                         const VkImageSubresource2EXT* pSubresource,
+                                         VkSubresourceLayout2EXT* pLayout) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+#endif
 #ifdef VK_EXT_4444_formats
 #endif
+#ifdef VK_EXT_device_fault
+    void vkGetDeviceFaultInfoEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkResult input_result,
+                                 VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts,
+                                 VkDeviceFaultInfoEXT* pFaultInfo) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 #endif
 #ifdef VK_NV_acquire_winrt_display
@@ -4012,6 +4363,10 @@ class VkDecoderSnapshot::Impl {
 #endif
 #ifdef VK_EXT_physical_device_drm
 #endif
+#ifdef VK_EXT_device_address_binding_report
+#endif
+#ifdef VK_EXT_depth_clip_control
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 #endif
 #ifdef VK_FUCHSIA_external_memory
@@ -4111,6 +4466,16 @@ class VkDecoderSnapshot::Impl {
         // TODO: Implement
     }
 #endif
+#ifdef VK_EXT_pipeline_properties
+    void vkGetPipelinePropertiesEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                    android::base::BumpPool* pool, VkResult input_result,
+                                    VkDevice device, const VkPipelineInfoEXT* pPipelineInfo,
+                                    VkBaseOutStructure* pPipelineProperties) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
     void vkCmdSetPatchControlPointsEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                        android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
@@ -4163,6 +4528,8 @@ class VkDecoderSnapshot::Impl {
         // TODO: Implement
     }
 #endif
+#ifdef VK_EXT_primitives_generated_query
+#endif
 #ifdef VK_GOOGLE_gfxstream
     void vkMapMemoryIntoAddressSpaceGOOGLE(const uint8_t* snapshotTraceBegin,
                                            size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -4344,9 +4711,22 @@ class VkDecoderSnapshot::Impl {
                          VkDeviceMemory memory) {
         // TODO: Implement
     }
+    void vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkDevice device, VkDescriptorSet descriptorSet,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+        uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
+        const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
+        const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
+        const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
+        const uint8_t* pInlineUniformBlockData) {
+        // TODO: Implement
+    }
 #endif
 #ifdef VK_EXT_global_priority_query
 #endif
+#ifdef VK_EXT_image_view_min_lod
+#endif
 #ifdef VK_EXT_multi_draw
     void vkCmdDrawMultiEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                            android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
@@ -4362,8 +4742,111 @@ class VkDecoderSnapshot::Impl {
         // TODO: Implement
     }
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+#endif
+#ifdef VK_EXT_shader_tile_image
+#endif
+#ifdef VK_EXT_opacity_micromap
+    void vkCreateMicromapEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                             android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                             const VkMicromapCreateInfoEXT* pCreateInfo,
+                             const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) {
+        // TODO: Implement
+    }
+    void vkDestroyMicromapEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                              android::base::BumpPool* pool, VkDevice device,
+                              VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) {
+        // TODO: Implement
+    }
+    void vkCmdBuildMicromapsEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) {
+        // TODO: Implement
+    }
+    void vkBuildMicromapsEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                             android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                             VkDeferredOperationKHR deferredOperation, uint32_t infoCount,
+                             const VkMicromapBuildInfoEXT* pInfos) {
+        // TODO: Implement
+    }
+    void vkCopyMicromapEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                           android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                           VkDeferredOperationKHR deferredOperation,
+                           const VkCopyMicromapInfoEXT* pInfo) {
+        // TODO: Implement
+    }
+    void vkCopyMicromapToMemoryEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkResult input_result,
+                                   VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                   const VkCopyMicromapToMemoryInfoEXT* pInfo) {
+        // TODO: Implement
+    }
+    void vkCopyMemoryToMicromapEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkResult input_result,
+                                   VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                   const VkCopyMemoryToMicromapInfoEXT* pInfo) {
+        // TODO: Implement
+    }
+    void vkWriteMicromapsPropertiesEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkResult input_result,
+                                       VkDevice device, uint32_t micromapCount,
+                                       const VkMicromapEXT* pMicromaps, VkQueryType queryType,
+                                       size_t dataSize, void* pData, size_t stride) {
+        // TODO: Implement
+    }
+    void vkCmdCopyMicromapEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                              android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                              const VkCopyMicromapInfoEXT* pInfo) {
+        // TODO: Implement
+    }
+    void vkCmdCopyMicromapToMemoryEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                      android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                      const VkCopyMicromapToMemoryInfoEXT* pInfo) {
+        // TODO: Implement
+    }
+    void vkCmdCopyMemoryToMicromapEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                      android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                      const VkCopyMemoryToMicromapInfoEXT* pInfo) {
+        // TODO: Implement
+    }
+    void vkCmdWriteMicromapsPropertiesEXT(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer, uint32_t micromapCount,
+                                          const VkMicromapEXT* pMicromaps, VkQueryType queryType,
+                                          VkQueryPool queryPool, uint32_t firstQuery) {
+        // TODO: Implement
+    }
+    void vkGetDeviceMicromapCompatibilityEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo,
+        VkAccelerationStructureCompatibilityKHR* pCompatibility) {
+        // TODO: Implement
+    }
+    void vkGetMicromapBuildSizesEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                    android::base::BumpPool* pool, VkDevice device,
+                                    VkAccelerationStructureBuildTypeKHR buildType,
+                                    const VkMicromapBuildInfoEXT* pBuildInfo,
+                                    VkMicromapBuildSizesInfoEXT* pSizeInfo) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_NV_displacement_micromap
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+    void vkCmdDrawClusterHUAWEI(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
+        // TODO: Implement
+    }
+    void vkCmdDrawClusterIndirectHUAWEI(const uint8_t* snapshotTraceBegin,
+                                        size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                        VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                        VkDeviceSize offset) {
+        // TODO: Implement
+    }
+#endif
 #ifdef VK_EXT_border_color_swizzle
 #endif
 #ifdef VK_EXT_pageable_device_local_memory
@@ -4373,6 +4856,384 @@ class VkDecoderSnapshot::Impl {
         // TODO: Implement
     }
 #endif
+#ifdef VK_ARM_shader_core_properties
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+    void vkGetDescriptorSetLayoutHostMappingInfoVALVE(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference,
+        VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) {
+        // TODO: Implement
+    }
+    void vkGetDescriptorSetHostMappingVALVE(const uint8_t* snapshotTraceBegin,
+                                            size_t snapshotTraceBytes,
+                                            android::base::BumpPool* pool, VkDevice device,
+                                            VkDescriptorSet descriptorSet, void** ppData) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+#endif
+#ifdef VK_NV_copy_memory_indirect
+    void vkCmdCopyMemoryIndirectNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   VkDeviceAddress copyBufferAddress, uint32_t copyCount,
+                                   uint32_t stride) {
+        // TODO: Implement
+    }
+    void vkCmdCopyMemoryToImageIndirectNV(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkDeviceAddress copyBufferAddress, uint32_t copyCount,
+                                          uint32_t stride, VkImage dstImage,
+                                          VkImageLayout dstImageLayout,
+                                          const VkImageSubresourceLayers* pImageSubresources) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_NV_memory_decompression
+    void vkCmdDecompressMemoryNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                 uint32_t decompressRegionCount,
+                                 const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) {
+        // TODO: Implement
+    }
+    void vkCmdDecompressMemoryIndirectCountNV(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress,
+        VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_NV_linear_color_attachment
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+#endif
+#ifdef VK_QCOM_image_processing
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+    void vkCmdSetTessellationDomainOriginEXT(const uint8_t* snapshotTraceBegin,
+                                             size_t snapshotTraceBytes,
+                                             android::base::BumpPool* pool,
+                                             VkCommandBuffer commandBuffer,
+                                             VkTessellationDomainOrigin domainOrigin) {
+        // TODO: Implement
+    }
+    void vkCmdSetDepthClampEnableEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                     VkBool32 depthClampEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetPolygonModeEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                VkPolygonMode polygonMode) {
+        // TODO: Implement
+    }
+    void vkCmdSetRasterizationSamplesEXT(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer,
+                                         VkSampleCountFlagBits rasterizationSamples) {
+        // TODO: Implement
+    }
+    void vkCmdSetSampleMaskEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                               android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                               VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) {
+        // TODO: Implement
+    }
+    void vkCmdSetAlphaToCoverageEnableEXT(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkBool32 alphaToCoverageEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetAlphaToOneEnableEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                     VkBool32 alphaToOneEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetLogicOpEnableEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                  android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                  VkBool32 logicOpEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetColorBlendEnableEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                     uint32_t firstAttachment, uint32_t attachmentCount,
+                                     const VkBool32* pColorBlendEnables) {
+        // TODO: Implement
+    }
+    void vkCmdSetColorBlendEquationEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                       uint32_t firstAttachment, uint32_t attachmentCount,
+                                       const VkColorBlendEquationEXT* pColorBlendEquations) {
+        // TODO: Implement
+    }
+    void vkCmdSetColorWriteMaskEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   uint32_t firstAttachment, uint32_t attachmentCount,
+                                   const VkColorComponentFlags* pColorWriteMasks) {
+        // TODO: Implement
+    }
+    void vkCmdSetRasterizationStreamEXT(const uint8_t* snapshotTraceBegin,
+                                        size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                        VkCommandBuffer commandBuffer,
+                                        uint32_t rasterizationStream) {
+        // TODO: Implement
+    }
+    void vkCmdSetConservativeRasterizationModeEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkCommandBuffer commandBuffer,
+        VkConservativeRasterizationModeEXT conservativeRasterizationMode) {
+        // TODO: Implement
+    }
+    void vkCmdSetExtraPrimitiveOverestimationSizeEXT(const uint8_t* snapshotTraceBegin,
+                                                     size_t snapshotTraceBytes,
+                                                     android::base::BumpPool* pool,
+                                                     VkCommandBuffer commandBuffer,
+                                                     float extraPrimitiveOverestimationSize) {
+        // TODO: Implement
+    }
+    void vkCmdSetDepthClipEnableEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                    android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                    VkBool32 depthClipEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetSampleLocationsEnableEXT(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkBool32 sampleLocationsEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetColorBlendAdvancedEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                       uint32_t firstAttachment, uint32_t attachmentCount,
+                                       const VkColorBlendAdvancedEXT* pColorBlendAdvanced) {
+        // TODO: Implement
+    }
+    void vkCmdSetProvokingVertexModeEXT(const uint8_t* snapshotTraceBegin,
+                                        size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                        VkCommandBuffer commandBuffer,
+                                        VkProvokingVertexModeEXT provokingVertexMode) {
+        // TODO: Implement
+    }
+    void vkCmdSetLineRasterizationModeEXT(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkLineRasterizationModeEXT lineRasterizationMode) {
+        // TODO: Implement
+    }
+    void vkCmdSetLineStippleEnableEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                      android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                      VkBool32 stippledLineEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetDepthClipNegativeOneToOneEXT(const uint8_t* snapshotTraceBegin,
+                                              size_t snapshotTraceBytes,
+                                              android::base::BumpPool* pool,
+                                              VkCommandBuffer commandBuffer,
+                                              VkBool32 negativeOneToOne) {
+        // TODO: Implement
+    }
+    void vkCmdSetViewportWScalingEnableNV(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkBool32 viewportWScalingEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetViewportSwizzleNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   uint32_t firstViewport, uint32_t viewportCount,
+                                   const VkViewportSwizzleNV* pViewportSwizzles) {
+        // TODO: Implement
+    }
+    void vkCmdSetCoverageToColorEnableNV(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer,
+                                         VkBool32 coverageToColorEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetCoverageToColorLocationNV(const uint8_t* snapshotTraceBegin,
+                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                           VkCommandBuffer commandBuffer,
+                                           uint32_t coverageToColorLocation) {
+        // TODO: Implement
+    }
+    void vkCmdSetCoverageModulationModeNV(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkCoverageModulationModeNV coverageModulationMode) {
+        // TODO: Implement
+    }
+    void vkCmdSetCoverageModulationTableEnableNV(const uint8_t* snapshotTraceBegin,
+                                                 size_t snapshotTraceBytes,
+                                                 android::base::BumpPool* pool,
+                                                 VkCommandBuffer commandBuffer,
+                                                 VkBool32 coverageModulationTableEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetCoverageModulationTableNV(const uint8_t* snapshotTraceBegin,
+                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                           VkCommandBuffer commandBuffer,
+                                           uint32_t coverageModulationTableCount,
+                                           const float* pCoverageModulationTable) {
+        // TODO: Implement
+    }
+    void vkCmdSetShadingRateImageEnableNV(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkBool32 shadingRateImageEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetRepresentativeFragmentTestEnableNV(const uint8_t* snapshotTraceBegin,
+                                                    size_t snapshotTraceBytes,
+                                                    android::base::BumpPool* pool,
+                                                    VkCommandBuffer commandBuffer,
+                                                    VkBool32 representativeFragmentTestEnable) {
+        // TODO: Implement
+    }
+    void vkCmdSetCoverageReductionModeNV(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer,
+                                         VkCoverageReductionModeNV coverageReductionMode) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+#endif
+#ifdef VK_EXT_shader_module_identifier
+    void vkGetShaderModuleIdentifierEXT(const uint8_t* snapshotTraceBegin,
+                                        size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                        VkDevice device, VkShaderModule shaderModule,
+                                        VkShaderModuleIdentifierEXT* pIdentifier) {
+        // TODO: Implement
+    }
+    void vkGetShaderModuleCreateInfoIdentifierEXT(const uint8_t* snapshotTraceBegin,
+                                                  size_t snapshotTraceBytes,
+                                                  android::base::BumpPool* pool, VkDevice device,
+                                                  const VkShaderModuleCreateInfo* pCreateInfo,
+                                                  VkShaderModuleIdentifierEXT* pIdentifier) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+    void vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkPhysicalDevice physicalDevice,
+        const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount,
+        VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) {
+        // TODO: Implement
+    }
+    void vkCreateOpticalFlowSessionNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                      android::base::BumpPool* pool, VkResult input_result,
+                                      VkDevice device,
+                                      const VkOpticalFlowSessionCreateInfoNV* pCreateInfo,
+                                      const VkAllocationCallbacks* pAllocator,
+                                      VkOpticalFlowSessionNV* pSession) {
+        // TODO: Implement
+    }
+    void vkDestroyOpticalFlowSessionNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkDevice device,
+                                       VkOpticalFlowSessionNV session,
+                                       const VkAllocationCallbacks* pAllocator) {
+        // TODO: Implement
+    }
+    void vkBindOpticalFlowSessionImageNV(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkResult input_result, VkDevice device,
+                                         VkOpticalFlowSessionNV session,
+                                         VkOpticalFlowSessionBindingPointNV bindingPoint,
+                                         VkImageView view, VkImageLayout layout) {
+        // TODO: Implement
+    }
+    void vkCmdOpticalFlowExecuteNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   VkOpticalFlowSessionNV session,
+                                   const VkOpticalFlowExecuteInfoNV* pExecuteInfo) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_EXT_legacy_dithering
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+#endif
+#ifdef VK_EXT_shader_object
+    void vkCreateShadersEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                            android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                            uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos,
+                            const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) {
+        // TODO: Implement
+    }
+    void vkDestroyShaderEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                            android::base::BumpPool* pool, VkDevice device, VkShaderEXT shader,
+                            const VkAllocationCallbacks* pAllocator) {
+        // TODO: Implement
+    }
+    void vkGetShaderBinaryDataEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                  android::base::BumpPool* pool, VkResult input_result,
+                                  VkDevice device, VkShaderEXT shader, size_t* pDataSize,
+                                  void* pData) {
+        // TODO: Implement
+    }
+    void vkCmdBindShadersEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                             android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                             uint32_t stageCount, const VkShaderStageFlagBits* pStages,
+                             const VkShaderEXT* pShaders) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_QCOM_tile_properties
+    void vkGetFramebufferTilePropertiesQCOM(const uint8_t* snapshotTraceBegin,
+                                            size_t snapshotTraceBytes,
+                                            android::base::BumpPool* pool, VkResult input_result,
+                                            VkDevice device, VkFramebuffer framebuffer,
+                                            uint32_t* pPropertiesCount,
+                                            VkTilePropertiesQCOM* pProperties) {
+        // TODO: Implement
+    }
+    void vkGetDynamicRenderingTilePropertiesQCOM(const uint8_t* snapshotTraceBegin,
+                                                 size_t snapshotTraceBytes,
+                                                 android::base::BumpPool* pool,
+                                                 VkResult input_result, VkDevice device,
+                                                 const VkRenderingInfo* pRenderingInfo,
+                                                 VkTilePropertiesQCOM* pProperties) {
+        // TODO: Implement
+    }
+#endif
+#ifdef VK_SEC_amigo_profiling
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+    void vkCmdSetAttachmentFeedbackLoopEnableEXT(const uint8_t* snapshotTraceBegin,
+                                                 size_t snapshotTraceBytes,
+                                                 android::base::BumpPool* pool,
+                                                 VkCommandBuffer commandBuffer,
+                                                 VkImageAspectFlags aspectMask) {
+        // TODO: Implement
+    }
+#endif
 #ifdef VK_KHR_acceleration_structure
     void vkCreateAccelerationStructureKHR(const uint8_t* snapshotTraceBegin,
                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -4550,6 +5411,25 @@ class VkDecoderSnapshot::Impl {
 #endif
 #ifdef VK_KHR_ray_query
 #endif
+#ifdef VK_EXT_mesh_shader
+    void vkCmdDrawMeshTasksEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                               android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                               uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) {
+        // TODO: Implement
+    }
+    void vkCmdDrawMeshTasksIndirectEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                       VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount,
+                                       uint32_t stride) {
+        // TODO: Implement
+    }
+    void vkCmdDrawMeshTasksIndirectCountEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer,
+        VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
+        // TODO: Implement
+    }
+#endif
 
    private:
     android::base::Lock mLock;
@@ -6286,6 +7166,355 @@ void VkDecoderSnapshot::vkGetDeviceMemoryOpaqueCaptureAddress(
                                                  input_result, device, pInfo);
 }
 #endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkGetPhysicalDeviceToolProperties(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
+    VkPhysicalDeviceToolProperties* pToolProperties) {
+    mImpl->vkGetPhysicalDeviceToolProperties(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                             input_result, physicalDevice, pToolCount,
+                                             pToolProperties);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCreatePrivateDataSlot(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
+    mImpl->vkCreatePrivateDataSlot(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+                                   device, pCreateInfo, pAllocator, pPrivateDataSlot);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkDestroyPrivateDataSlot(const uint8_t* snapshotTraceBegin,
+                                                 size_t snapshotTraceBytes,
+                                                 android::base::BumpPool* pool, VkDevice device,
+                                                 VkPrivateDataSlot privateDataSlot,
+                                                 const VkAllocationCallbacks* pAllocator) {
+    mImpl->vkDestroyPrivateDataSlot(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                    privateDataSlot, pAllocator);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkSetPrivateData(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkResult input_result, VkDevice device,
+                                         VkObjectType objectType, uint64_t objectHandle,
+                                         VkPrivateDataSlot privateDataSlot, uint64_t data) {
+    mImpl->vkSetPrivateData(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device,
+                            objectType, objectHandle, privateDataSlot, data);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkGetPrivateData(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkDevice device, VkObjectType objectType,
+                                         uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
+                                         uint64_t* pData) {
+    mImpl->vkGetPrivateData(snapshotTraceBegin, snapshotTraceBytes, pool, device, objectType,
+                            objectHandle, privateDataSlot, pData);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetEvent2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                       VkEvent event, const VkDependencyInfo* pDependencyInfo) {
+    mImpl->vkCmdSetEvent2(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, event,
+                          pDependencyInfo);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdResetEvent2(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer, VkEvent event,
+                                         VkPipelineStageFlags2 stageMask) {
+    mImpl->vkCmdResetEvent2(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, event,
+                            stageMask);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdWaitEvents2(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer, uint32_t eventCount,
+                                         const VkEvent* pEvents,
+                                         const VkDependencyInfo* pDependencyInfos) {
+    mImpl->vkCmdWaitEvents2(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, eventCount,
+                            pEvents, pDependencyInfos);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdPipelineBarrier2(const uint8_t* snapshotTraceBegin,
+                                              size_t snapshotTraceBytes,
+                                              android::base::BumpPool* pool,
+                                              VkCommandBuffer commandBuffer,
+                                              const VkDependencyInfo* pDependencyInfo) {
+    mImpl->vkCmdPipelineBarrier2(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                 pDependencyInfo);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdWriteTimestamp2(const uint8_t* snapshotTraceBegin,
+                                             size_t snapshotTraceBytes,
+                                             android::base::BumpPool* pool,
+                                             VkCommandBuffer commandBuffer,
+                                             VkPipelineStageFlags2 stage, VkQueryPool queryPool,
+                                             uint32_t query) {
+    mImpl->vkCmdWriteTimestamp2(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, stage,
+                                queryPool, query);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkQueueSubmit2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkResult input_result,
+                                       VkQueue queue, uint32_t submitCount,
+                                       const VkSubmitInfo2* pSubmits, VkFence fence) {
+    mImpl->vkQueueSubmit2(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, queue,
+                          submitCount, pSubmits, fence);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdCopyBuffer2(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer,
+                                         const VkCopyBufferInfo2* pCopyBufferInfo) {
+    mImpl->vkCmdCopyBuffer2(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                            pCopyBufferInfo);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdCopyImage2(const uint8_t* snapshotTraceBegin,
+                                        size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                        VkCommandBuffer commandBuffer,
+                                        const VkCopyImageInfo2* pCopyImageInfo) {
+    mImpl->vkCmdCopyImage2(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                           pCopyImageInfo);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdCopyBufferToImage2(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
+    mImpl->vkCmdCopyBufferToImage2(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                   pCopyBufferToImageInfo);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdCopyImageToBuffer2(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
+    mImpl->vkCmdCopyImageToBuffer2(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                   pCopyImageToBufferInfo);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdBlitImage2(const uint8_t* snapshotTraceBegin,
+                                        size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                        VkCommandBuffer commandBuffer,
+                                        const VkBlitImageInfo2* pBlitImageInfo) {
+    mImpl->vkCmdBlitImage2(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                           pBlitImageInfo);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdResolveImage2(const uint8_t* snapshotTraceBegin,
+                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                           VkCommandBuffer commandBuffer,
+                                           const VkResolveImageInfo2* pResolveImageInfo) {
+    mImpl->vkCmdResolveImage2(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                              pResolveImageInfo);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdBeginRendering(const uint8_t* snapshotTraceBegin,
+                                            size_t snapshotTraceBytes,
+                                            android::base::BumpPool* pool,
+                                            VkCommandBuffer commandBuffer,
+                                            const VkRenderingInfo* pRenderingInfo) {
+    mImpl->vkCmdBeginRendering(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                               pRenderingInfo);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdEndRendering(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer) {
+    mImpl->vkCmdEndRendering(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetCullMode(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) {
+    mImpl->vkCmdSetCullMode(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, cullMode);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetFrontFace(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer, VkFrontFace frontFace) {
+    mImpl->vkCmdSetFrontFace(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                             frontFace);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetPrimitiveTopology(const uint8_t* snapshotTraceBegin,
+                                                  size_t snapshotTraceBytes,
+                                                  android::base::BumpPool* pool,
+                                                  VkCommandBuffer commandBuffer,
+                                                  VkPrimitiveTopology primitiveTopology) {
+    mImpl->vkCmdSetPrimitiveTopology(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                     primitiveTopology);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetViewportWithCount(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
+    mImpl->vkCmdSetViewportWithCount(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                     viewportCount, pViewports);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetScissorWithCount(const uint8_t* snapshotTraceBegin,
+                                                 size_t snapshotTraceBytes,
+                                                 android::base::BumpPool* pool,
+                                                 VkCommandBuffer commandBuffer,
+                                                 uint32_t scissorCount, const VkRect2D* pScissors) {
+    mImpl->vkCmdSetScissorWithCount(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                    scissorCount, pScissors);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdBindVertexBuffers2(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
+    const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes,
+    const VkDeviceSize* pStrides) {
+    mImpl->vkCmdBindVertexBuffers2(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                   firstBinding, bindingCount, pBuffers, pOffsets, pSizes,
+                                   pStrides);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetDepthTestEnable(const uint8_t* snapshotTraceBegin,
+                                                size_t snapshotTraceBytes,
+                                                android::base::BumpPool* pool,
+                                                VkCommandBuffer commandBuffer,
+                                                VkBool32 depthTestEnable) {
+    mImpl->vkCmdSetDepthTestEnable(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                   depthTestEnable);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetDepthWriteEnable(const uint8_t* snapshotTraceBegin,
+                                                 size_t snapshotTraceBytes,
+                                                 android::base::BumpPool* pool,
+                                                 VkCommandBuffer commandBuffer,
+                                                 VkBool32 depthWriteEnable) {
+    mImpl->vkCmdSetDepthWriteEnable(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                    depthWriteEnable);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetDepthCompareOp(const uint8_t* snapshotTraceBegin,
+                                               size_t snapshotTraceBytes,
+                                               android::base::BumpPool* pool,
+                                               VkCommandBuffer commandBuffer,
+                                               VkCompareOp depthCompareOp) {
+    mImpl->vkCmdSetDepthCompareOp(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                  depthCompareOp);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetDepthBoundsTestEnable(const uint8_t* snapshotTraceBegin,
+                                                      size_t snapshotTraceBytes,
+                                                      android::base::BumpPool* pool,
+                                                      VkCommandBuffer commandBuffer,
+                                                      VkBool32 depthBoundsTestEnable) {
+    mImpl->vkCmdSetDepthBoundsTestEnable(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                         commandBuffer, depthBoundsTestEnable);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetStencilTestEnable(const uint8_t* snapshotTraceBegin,
+                                                  size_t snapshotTraceBytes,
+                                                  android::base::BumpPool* pool,
+                                                  VkCommandBuffer commandBuffer,
+                                                  VkBool32 stencilTestEnable) {
+    mImpl->vkCmdSetStencilTestEnable(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                     stencilTestEnable);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetStencilOp(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkStencilFaceFlags faceMask, VkStencilOp failOp,
+                                          VkStencilOp passOp, VkStencilOp depthFailOp,
+                                          VkCompareOp compareOp) {
+    mImpl->vkCmdSetStencilOp(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, faceMask,
+                             failOp, passOp, depthFailOp, compareOp);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetRasterizerDiscardEnable(const uint8_t* snapshotTraceBegin,
+                                                        size_t snapshotTraceBytes,
+                                                        android::base::BumpPool* pool,
+                                                        VkCommandBuffer commandBuffer,
+                                                        VkBool32 rasterizerDiscardEnable) {
+    mImpl->vkCmdSetRasterizerDiscardEnable(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                           commandBuffer, rasterizerDiscardEnable);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetDepthBiasEnable(const uint8_t* snapshotTraceBegin,
+                                                size_t snapshotTraceBytes,
+                                                android::base::BumpPool* pool,
+                                                VkCommandBuffer commandBuffer,
+                                                VkBool32 depthBiasEnable) {
+    mImpl->vkCmdSetDepthBiasEnable(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                   depthBiasEnable);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkCmdSetPrimitiveRestartEnable(const uint8_t* snapshotTraceBegin,
+                                                       size_t snapshotTraceBytes,
+                                                       android::base::BumpPool* pool,
+                                                       VkCommandBuffer commandBuffer,
+                                                       VkBool32 primitiveRestartEnable) {
+    mImpl->vkCmdSetPrimitiveRestartEnable(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                          commandBuffer, primitiveRestartEnable);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkGetDeviceBufferMemoryRequirements(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
+    VkMemoryRequirements2* pMemoryRequirements) {
+    mImpl->vkGetDeviceBufferMemoryRequirements(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                               pInfo, pMemoryRequirements);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkGetDeviceImageMemoryRequirements(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
+    VkMemoryRequirements2* pMemoryRequirements) {
+    mImpl->vkGetDeviceImageMemoryRequirements(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                              pInfo, pMemoryRequirements);
+}
+#endif
+#ifdef VK_VERSION_1_3
+void VkDecoderSnapshot::vkGetDeviceImageSparseMemoryRequirements(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
+    uint32_t* pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
+    mImpl->vkGetDeviceImageSparseMemoryRequirements(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                    device, pInfo, pSparseMemoryRequirementCount,
+                                                    pSparseMemoryRequirements);
+}
+#endif
 #ifdef VK_KHR_surface
 void VkDecoderSnapshot::vkDestroySurfaceKHR(const uint8_t* snapshotTraceBegin,
                                             size_t snapshotTraceBytes,
@@ -6591,8 +7820,8 @@ void VkDecoderSnapshot::vkGetPhysicalDeviceWin32PresentationSupportKHR(
 #ifdef VK_KHR_video_queue
 void VkDecoderSnapshot::vkGetPhysicalDeviceVideoCapabilitiesKHR(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
-    VkResult input_result, VkPhysicalDevice physicalDevice, const VkVideoProfileKHR* pVideoProfile,
-    VkVideoCapabilitiesKHR* pCapabilities) {
+    VkResult input_result, VkPhysicalDevice physicalDevice,
+    const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) {
     mImpl->vkGetPhysicalDeviceVideoCapabilitiesKHR(snapshotTraceBegin, snapshotTraceBytes, pool,
                                                    input_result, physicalDevice, pVideoProfile,
                                                    pCapabilities);
@@ -6632,21 +7861,21 @@ void VkDecoderSnapshot::vkDestroyVideoSessionKHR(const uint8_t* snapshotTraceBeg
 void VkDecoderSnapshot::vkGetVideoSessionMemoryRequirementsKHR(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
     VkResult input_result, VkDevice device, VkVideoSessionKHR videoSession,
-    uint32_t* pVideoSessionMemoryRequirementsCount,
-    VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements) {
-    mImpl->vkGetVideoSessionMemoryRequirementsKHR(
-        snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, videoSession,
-        pVideoSessionMemoryRequirementsCount, pVideoSessionMemoryRequirements);
+    uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) {
+    mImpl->vkGetVideoSessionMemoryRequirementsKHR(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                  input_result, device, videoSession,
+                                                  pMemoryRequirementsCount, pMemoryRequirements);
 }
 #endif
 #ifdef VK_KHR_video_queue
 void VkDecoderSnapshot::vkBindVideoSessionMemoryKHR(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
     VkResult input_result, VkDevice device, VkVideoSessionKHR videoSession,
-    uint32_t videoSessionBindMemoryCount, const VkVideoBindMemoryKHR* pVideoSessionBindMemories) {
+    uint32_t bindSessionMemoryInfoCount,
+    const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) {
     mImpl->vkBindVideoSessionMemoryKHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
-                                       device, videoSession, videoSessionBindMemoryCount,
-                                       pVideoSessionBindMemories);
+                                       device, videoSession, bindSessionMemoryInfoCount,
+                                       pBindSessionMemoryInfos);
 }
 #endif
 #ifdef VK_KHR_video_queue
@@ -6712,9 +7941,9 @@ void VkDecoderSnapshot::vkCmdDecodeVideoKHR(const uint8_t* snapshotTraceBegin,
                                             size_t snapshotTraceBytes,
                                             android::base::BumpPool* pool,
                                             VkCommandBuffer commandBuffer,
-                                            const VkVideoDecodeInfoKHR* pFrameInfo) {
+                                            const VkVideoDecodeInfoKHR* pDecodeInfo) {
     mImpl->vkCmdDecodeVideoKHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
-                               pFrameInfo);
+                               pDecodeInfo);
 }
 #endif
 #ifdef VK_KHR_dynamic_rendering
@@ -6722,7 +7951,7 @@ void VkDecoderSnapshot::vkCmdBeginRenderingKHR(const uint8_t* snapshotTraceBegin
                                                size_t snapshotTraceBytes,
                                                android::base::BumpPool* pool,
                                                VkCommandBuffer commandBuffer,
-                                               const VkRenderingInfoKHR* pRenderingInfo) {
+                                               const VkRenderingInfo* pRenderingInfo) {
     mImpl->vkCmdBeginRenderingKHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
                                   pRenderingInfo);
 }
@@ -7454,6 +8683,24 @@ void VkDecoderSnapshot::vkGetPipelineExecutableInternalRepresentationsKHR(
         pInternalRepresentationCount, pInternalRepresentations);
 }
 #endif
+#ifdef VK_KHR_map_memory2
+void VkDecoderSnapshot::vkMapMemory2KHR(const uint8_t* snapshotTraceBegin,
+                                        size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                        VkResult input_result, VkDevice device,
+                                        const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData) {
+    mImpl->vkMapMemory2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device,
+                           pMemoryMapInfo, ppData);
+}
+#endif
+#ifdef VK_KHR_map_memory2
+void VkDecoderSnapshot::vkUnmapMemory2KHR(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkResult input_result, VkDevice device,
+                                          const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo) {
+    mImpl->vkUnmapMemory2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device,
+                             pMemoryUnmapInfo);
+}
+#endif
 #ifdef VK_KHR_video_encode_queue
 void VkDecoderSnapshot::vkCmdEncodeVideoKHR(const uint8_t* snapshotTraceBegin,
                                             size_t snapshotTraceBytes,
@@ -7468,7 +8715,7 @@ void VkDecoderSnapshot::vkCmdEncodeVideoKHR(const uint8_t* snapshotTraceBegin,
 void VkDecoderSnapshot::vkCmdSetEvent2KHR(const uint8_t* snapshotTraceBegin,
                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
                                           VkCommandBuffer commandBuffer, VkEvent event,
-                                          const VkDependencyInfoKHR* pDependencyInfo) {
+                                          const VkDependencyInfo* pDependencyInfo) {
     mImpl->vkCmdSetEvent2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, event,
                              pDependencyInfo);
 }
@@ -7478,7 +8725,7 @@ void VkDecoderSnapshot::vkCmdResetEvent2KHR(const uint8_t* snapshotTraceBegin,
                                             size_t snapshotTraceBytes,
                                             android::base::BumpPool* pool,
                                             VkCommandBuffer commandBuffer, VkEvent event,
-                                            VkPipelineStageFlags2KHR stageMask) {
+                                            VkPipelineStageFlags2 stageMask) {
     mImpl->vkCmdResetEvent2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, event,
                                stageMask);
 }
@@ -7489,7 +8736,7 @@ void VkDecoderSnapshot::vkCmdWaitEvents2KHR(const uint8_t* snapshotTraceBegin,
                                             android::base::BumpPool* pool,
                                             VkCommandBuffer commandBuffer, uint32_t eventCount,
                                             const VkEvent* pEvents,
-                                            const VkDependencyInfoKHR* pDependencyInfos) {
+                                            const VkDependencyInfo* pDependencyInfos) {
     mImpl->vkCmdWaitEvents2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
                                eventCount, pEvents, pDependencyInfos);
 }
@@ -7499,7 +8746,7 @@ void VkDecoderSnapshot::vkCmdPipelineBarrier2KHR(const uint8_t* snapshotTraceBeg
                                                  size_t snapshotTraceBytes,
                                                  android::base::BumpPool* pool,
                                                  VkCommandBuffer commandBuffer,
-                                                 const VkDependencyInfoKHR* pDependencyInfo) {
+                                                 const VkDependencyInfo* pDependencyInfo) {
     mImpl->vkCmdPipelineBarrier2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
                                     pDependencyInfo);
 }
@@ -7509,8 +8756,8 @@ void VkDecoderSnapshot::vkCmdWriteTimestamp2KHR(const uint8_t* snapshotTraceBegi
                                                 size_t snapshotTraceBytes,
                                                 android::base::BumpPool* pool,
                                                 VkCommandBuffer commandBuffer,
-                                                VkPipelineStageFlags2KHR stage,
-                                                VkQueryPool queryPool, uint32_t query) {
+                                                VkPipelineStageFlags2 stage, VkQueryPool queryPool,
+                                                uint32_t query) {
     mImpl->vkCmdWriteTimestamp2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
                                    stage, queryPool, query);
 }
@@ -7519,17 +8766,19 @@ void VkDecoderSnapshot::vkCmdWriteTimestamp2KHR(const uint8_t* snapshotTraceBegi
 void VkDecoderSnapshot::vkQueueSubmit2KHR(const uint8_t* snapshotTraceBegin,
                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
                                           VkResult input_result, VkQueue queue,
-                                          uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits,
+                                          uint32_t submitCount, const VkSubmitInfo2* pSubmits,
                                           VkFence fence) {
     mImpl->vkQueueSubmit2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, queue,
                              submitCount, pSubmits, fence);
 }
 #endif
 #ifdef VK_KHR_synchronization2
-void VkDecoderSnapshot::vkCmdWriteBufferMarker2AMD(
-    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
-    VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer,
-    VkDeviceSize dstOffset, uint32_t marker) {
+void VkDecoderSnapshot::vkCmdWriteBufferMarker2AMD(const uint8_t* snapshotTraceBegin,
+                                                   size_t snapshotTraceBytes,
+                                                   android::base::BumpPool* pool,
+                                                   VkCommandBuffer commandBuffer,
+                                                   VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
+                                                   VkDeviceSize dstOffset, uint32_t marker) {
     mImpl->vkCmdWriteBufferMarker2AMD(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
                                       stage, dstBuffer, dstOffset, marker);
 }
@@ -7549,7 +8798,7 @@ void VkDecoderSnapshot::vkCmdCopyBuffer2KHR(const uint8_t* snapshotTraceBegin,
                                             size_t snapshotTraceBytes,
                                             android::base::BumpPool* pool,
                                             VkCommandBuffer commandBuffer,
-                                            const VkCopyBufferInfo2KHR* pCopyBufferInfo) {
+                                            const VkCopyBufferInfo2* pCopyBufferInfo) {
     mImpl->vkCmdCopyBuffer2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
                                pCopyBufferInfo);
 }
@@ -7558,7 +8807,7 @@ void VkDecoderSnapshot::vkCmdCopyBuffer2KHR(const uint8_t* snapshotTraceBegin,
 void VkDecoderSnapshot::vkCmdCopyImage2KHR(const uint8_t* snapshotTraceBegin,
                                            size_t snapshotTraceBytes, android::base::BumpPool* pool,
                                            VkCommandBuffer commandBuffer,
-                                           const VkCopyImageInfo2KHR* pCopyImageInfo) {
+                                           const VkCopyImageInfo2* pCopyImageInfo) {
     mImpl->vkCmdCopyImage2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
                               pCopyImageInfo);
 }
@@ -7566,7 +8815,7 @@ void VkDecoderSnapshot::vkCmdCopyImage2KHR(const uint8_t* snapshotTraceBegin,
 #ifdef VK_KHR_copy_commands2
 void VkDecoderSnapshot::vkCmdCopyBufferToImage2KHR(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
-    VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo) {
+    VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) {
     mImpl->vkCmdCopyBufferToImage2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
                                       pCopyBufferToImageInfo);
 }
@@ -7574,7 +8823,7 @@ void VkDecoderSnapshot::vkCmdCopyBufferToImage2KHR(
 #ifdef VK_KHR_copy_commands2
 void VkDecoderSnapshot::vkCmdCopyImageToBuffer2KHR(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
-    VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo) {
+    VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) {
     mImpl->vkCmdCopyImageToBuffer2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
                                       pCopyImageToBufferInfo);
 }
@@ -7583,7 +8832,7 @@ void VkDecoderSnapshot::vkCmdCopyImageToBuffer2KHR(
 void VkDecoderSnapshot::vkCmdBlitImage2KHR(const uint8_t* snapshotTraceBegin,
                                            size_t snapshotTraceBytes, android::base::BumpPool* pool,
                                            VkCommandBuffer commandBuffer,
-                                           const VkBlitImageInfo2KHR* pBlitImageInfo) {
+                                           const VkBlitImageInfo2* pBlitImageInfo) {
     mImpl->vkCmdBlitImage2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
                               pBlitImageInfo);
 }
@@ -7593,15 +8842,25 @@ void VkDecoderSnapshot::vkCmdResolveImage2KHR(const uint8_t* snapshotTraceBegin,
                                               size_t snapshotTraceBytes,
                                               android::base::BumpPool* pool,
                                               VkCommandBuffer commandBuffer,
-                                              const VkResolveImageInfo2KHR* pResolveImageInfo) {
+                                              const VkResolveImageInfo2* pResolveImageInfo) {
     mImpl->vkCmdResolveImage2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
                                  pResolveImageInfo);
 }
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+void VkDecoderSnapshot::vkCmdTraceRaysIndirect2KHR(const uint8_t* snapshotTraceBegin,
+                                                   size_t snapshotTraceBytes,
+                                                   android::base::BumpPool* pool,
+                                                   VkCommandBuffer commandBuffer,
+                                                   VkDeviceAddress indirectDeviceAddress) {
+    mImpl->vkCmdTraceRaysIndirect2KHR(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                      indirectDeviceAddress);
+}
+#endif
 #ifdef VK_KHR_maintenance4
 void VkDecoderSnapshot::vkGetDeviceBufferMemoryRequirementsKHR(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
-    VkDevice device, const VkDeviceBufferMemoryRequirementsKHR* pInfo,
+    VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo,
     VkMemoryRequirements2* pMemoryRequirements) {
     mImpl->vkGetDeviceBufferMemoryRequirementsKHR(snapshotTraceBegin, snapshotTraceBytes, pool,
                                                   device, pInfo, pMemoryRequirements);
@@ -7610,7 +8869,7 @@ void VkDecoderSnapshot::vkGetDeviceBufferMemoryRequirementsKHR(
 #ifdef VK_KHR_maintenance4
 void VkDecoderSnapshot::vkGetDeviceImageMemoryRequirementsKHR(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
-    VkDevice device, const VkDeviceImageMemoryRequirementsKHR* pInfo,
+    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
     VkMemoryRequirements2* pMemoryRequirements) {
     mImpl->vkGetDeviceImageMemoryRequirementsKHR(snapshotTraceBegin, snapshotTraceBytes, pool,
                                                  device, pInfo, pMemoryRequirements);
@@ -7619,7 +8878,7 @@ void VkDecoderSnapshot::vkGetDeviceImageMemoryRequirementsKHR(
 #ifdef VK_KHR_maintenance4
 void VkDecoderSnapshot::vkGetDeviceImageSparseMemoryRequirementsKHR(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
-    VkDevice device, const VkDeviceImageMemoryRequirementsKHR* pInfo,
+    VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
     uint32_t* pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) {
     mImpl->vkGetDeviceImageSparseMemoryRequirementsKHR(snapshotTraceBegin, snapshotTraceBytes, pool,
@@ -7657,6 +8916,17 @@ void VkDecoderSnapshot::vkQueueSignalReleaseImageANDROID(
                                             pWaitSemaphores, image, pNativeFenceFd);
 }
 #endif
+#ifdef VK_ANDROID_native_buffer
+void VkDecoderSnapshot::vkGetSwapchainGrallocUsage2ANDROID(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
+    VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
+    uint64_t* grallocProducerUsage) {
+    mImpl->vkGetSwapchainGrallocUsage2ANDROID(
+        snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, format, imageUsage,
+        swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage);
+}
+#endif
 #ifdef VK_EXT_debug_report
 void VkDecoderSnapshot::vkCreateDebugReportCallbackEXT(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -8071,6 +9341,24 @@ void VkDecoderSnapshot::vkCmdSetDiscardRectangleEXT(
                                        pDiscardRectangles);
 }
 #endif
+#ifdef VK_EXT_discard_rectangles
+void VkDecoderSnapshot::vkCmdSetDiscardRectangleEnableEXT(const uint8_t* snapshotTraceBegin,
+                                                          size_t snapshotTraceBytes,
+                                                          android::base::BumpPool* pool,
+                                                          VkCommandBuffer commandBuffer,
+                                                          VkBool32 discardRectangleEnable) {
+    mImpl->vkCmdSetDiscardRectangleEnableEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                             commandBuffer, discardRectangleEnable);
+}
+#endif
+#ifdef VK_EXT_discard_rectangles
+void VkDecoderSnapshot::vkCmdSetDiscardRectangleModeEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) {
+    mImpl->vkCmdSetDiscardRectangleModeEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                           commandBuffer, discardRectangleMode);
+}
+#endif
 #ifdef VK_EXT_hdr_metadata
 void VkDecoderSnapshot::vkSetHdrMetadataEXT(const uint8_t* snapshotTraceBegin,
                                             size_t snapshotTraceBytes,
@@ -8100,51 +9388,6 @@ void VkDecoderSnapshot::vkCreateMacOSSurfaceMVK(
                                    instance, pCreateInfo, pAllocator, pSurface);
 }
 #endif
-#ifdef VK_MVK_moltenvk
-void VkDecoderSnapshot::vkGetMTLDeviceMVK(const uint8_t* snapshotTraceBegin,
-                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
-                                          VkPhysicalDevice physicalDevice, void** pMTLDevice) {
-    mImpl->vkGetMTLDeviceMVK(snapshotTraceBegin, snapshotTraceBytes, pool, physicalDevice,
-                             pMTLDevice);
-}
-#endif
-#ifdef VK_MVK_moltenvk
-void VkDecoderSnapshot::vkSetMTLTextureMVK(const uint8_t* snapshotTraceBegin,
-                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
-                                           VkResult input_result, VkImage image, void* mtlTexture) {
-    mImpl->vkSetMTLTextureMVK(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, image,
-                              mtlTexture);
-}
-#endif
-#ifdef VK_MVK_moltenvk
-void VkDecoderSnapshot::vkGetMTLTextureMVK(const uint8_t* snapshotTraceBegin,
-                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
-                                           VkImage image, void** pMTLTexture) {
-    mImpl->vkGetMTLTextureMVK(snapshotTraceBegin, snapshotTraceBytes, pool, image, pMTLTexture);
-}
-#endif
-#ifdef VK_MVK_moltenvk
-void VkDecoderSnapshot::vkGetMTLBufferMVK(const uint8_t* snapshotTraceBegin,
-                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
-                                          VkBuffer buffer, void** pMTLBuffer) {
-    mImpl->vkGetMTLBufferMVK(snapshotTraceBegin, snapshotTraceBytes, pool, buffer, pMTLBuffer);
-}
-#endif
-#ifdef VK_MVK_moltenvk
-void VkDecoderSnapshot::vkUseIOSurfaceMVK(const uint8_t* snapshotTraceBegin,
-                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
-                                          VkResult input_result, VkImage image, void* ioSurface) {
-    mImpl->vkUseIOSurfaceMVK(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, image,
-                             ioSurface);
-}
-#endif
-#ifdef VK_MVK_moltenvk
-void VkDecoderSnapshot::vkGetIOSurfaceMVK(const uint8_t* snapshotTraceBegin,
-                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
-                                          VkImage image, void** pIOSurface) {
-    mImpl->vkGetIOSurfaceMVK(snapshotTraceBegin, snapshotTraceBytes, pool, image, pIOSurface);
-}
-#endif
 #ifdef VK_EXT_debug_utils
 void VkDecoderSnapshot::vkSetDebugUtilsObjectNameEXT(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -8570,6 +9813,16 @@ void VkDecoderSnapshot::vkCmdDrawMeshTasksIndirectCountNV(
 }
 #endif
 #ifdef VK_NV_scissor_exclusive
+void VkDecoderSnapshot::vkCmdSetExclusiveScissorEnableNV(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount,
+    const VkBool32* pExclusiveScissorEnables) {
+    mImpl->vkCmdSetExclusiveScissorEnableNV(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                            commandBuffer, firstExclusiveScissor,
+                                            exclusiveScissorCount, pExclusiveScissorEnables);
+}
+#endif
+#ifdef VK_NV_scissor_exclusive
 void VkDecoderSnapshot::vkCmdSetExclusiveScissorNV(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
     VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount,
@@ -8725,7 +9978,7 @@ void VkDecoderSnapshot::vkGetBufferDeviceAddressEXT(const uint8_t* snapshotTrace
 void VkDecoderSnapshot::vkGetPhysicalDeviceToolPropertiesEXT(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
     VkResult input_result, VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
-    VkPhysicalDeviceToolPropertiesEXT* pToolProperties) {
+    VkPhysicalDeviceToolProperties* pToolProperties) {
     mImpl->vkGetPhysicalDeviceToolPropertiesEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
                                                 input_result, physicalDevice, pToolCount,
                                                 pToolProperties);
@@ -8933,6 +10186,14 @@ void VkDecoderSnapshot::vkCmdSetStencilOpEXT(
                                 faceMask, failOp, passOp, depthFailOp, compareOp);
 }
 #endif
+#ifdef VK_EXT_swapchain_maintenance1
+void VkDecoderSnapshot::vkReleaseSwapchainImagesEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) {
+    mImpl->vkReleaseSwapchainImagesEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+                                       device, pReleaseInfo);
+}
+#endif
 #ifdef VK_NV_device_generated_commands
 void VkDecoderSnapshot::vkGetGeneratedCommandsMemoryRequirementsNV(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -9012,8 +10273,8 @@ void VkDecoderSnapshot::vkGetDrmDisplayEXT(const uint8_t* snapshotTraceBegin,
 #ifdef VK_EXT_private_data
 void VkDecoderSnapshot::vkCreatePrivateDataSlotEXT(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
-    VkResult input_result, VkDevice device, const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
-    const VkAllocationCallbacks* pAllocator, VkPrivateDataSlotEXT* pPrivateDataSlot) {
+    VkResult input_result, VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) {
     mImpl->vkCreatePrivateDataSlotEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
                                       device, pCreateInfo, pAllocator, pPrivateDataSlot);
 }
@@ -9022,7 +10283,7 @@ void VkDecoderSnapshot::vkCreatePrivateDataSlotEXT(
 void VkDecoderSnapshot::vkDestroyPrivateDataSlotEXT(const uint8_t* snapshotTraceBegin,
                                                     size_t snapshotTraceBytes,
                                                     android::base::BumpPool* pool, VkDevice device,
-                                                    VkPrivateDataSlotEXT privateDataSlot,
+                                                    VkPrivateDataSlot privateDataSlot,
                                                     const VkAllocationCallbacks* pAllocator) {
     mImpl->vkDestroyPrivateDataSlotEXT(snapshotTraceBegin, snapshotTraceBytes, pool, device,
                                        privateDataSlot, pAllocator);
@@ -9034,7 +10295,7 @@ void VkDecoderSnapshot::vkSetPrivateDataEXT(const uint8_t* snapshotTraceBegin,
                                             android::base::BumpPool* pool, VkResult input_result,
                                             VkDevice device, VkObjectType objectType,
                                             uint64_t objectHandle,
-                                            VkPrivateDataSlotEXT privateDataSlot, uint64_t data) {
+                                            VkPrivateDataSlot privateDataSlot, uint64_t data) {
     mImpl->vkSetPrivateDataEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device,
                                objectType, objectHandle, privateDataSlot, data);
 }
@@ -9044,11 +10305,121 @@ void VkDecoderSnapshot::vkGetPrivateDataEXT(const uint8_t* snapshotTraceBegin,
                                             size_t snapshotTraceBytes,
                                             android::base::BumpPool* pool, VkDevice device,
                                             VkObjectType objectType, uint64_t objectHandle,
-                                            VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData) {
+                                            VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
     mImpl->vkGetPrivateDataEXT(snapshotTraceBegin, snapshotTraceBytes, pool, device, objectType,
                                objectHandle, privateDataSlot, pData);
 }
 #endif
+#ifdef VK_EXT_metal_objects
+void VkDecoderSnapshot::vkExportMetalObjectsEXT(const uint8_t* snapshotTraceBegin,
+                                                size_t snapshotTraceBytes,
+                                                android::base::BumpPool* pool, VkDevice device,
+                                                VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) {
+    mImpl->vkExportMetalObjectsEXT(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                   pMetalObjectsInfo);
+}
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void VkDecoderSnapshot::vkGetDescriptorSetLayoutSizeEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) {
+    mImpl->vkGetDescriptorSetLayoutSizeEXT(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                           layout, pLayoutSizeInBytes);
+}
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void VkDecoderSnapshot::vkGetDescriptorSetLayoutBindingOffsetEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) {
+    mImpl->vkGetDescriptorSetLayoutBindingOffsetEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                    device, layout, binding, pOffset);
+}
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void VkDecoderSnapshot::vkGetDescriptorEXT(const uint8_t* snapshotTraceBegin,
+                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                           VkDevice device,
+                                           const VkDescriptorGetInfoEXT* pDescriptorInfo,
+                                           size_t dataSize, void* pDescriptor) {
+    mImpl->vkGetDescriptorEXT(snapshotTraceBegin, snapshotTraceBytes, pool, device, pDescriptorInfo,
+                              dataSize, pDescriptor);
+}
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void VkDecoderSnapshot::vkCmdBindDescriptorBuffersEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, uint32_t bufferCount,
+    const VkDescriptorBufferBindingInfoEXT* pBindingInfos) {
+    mImpl->vkCmdBindDescriptorBuffersEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                         commandBuffer, bufferCount, pBindingInfos);
+}
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void VkDecoderSnapshot::vkCmdSetDescriptorBufferOffsetsEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
+    uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices,
+    const VkDeviceSize* pOffsets) {
+    mImpl->vkCmdSetDescriptorBufferOffsetsEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                              commandBuffer, pipelineBindPoint, layout, firstSet,
+                                              setCount, pBufferIndices, pOffsets);
+}
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void VkDecoderSnapshot::vkCmdBindDescriptorBufferEmbeddedSamplersEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
+    uint32_t set) {
+    mImpl->vkCmdBindDescriptorBufferEmbeddedSamplersEXT(snapshotTraceBegin, snapshotTraceBytes,
+                                                        pool, commandBuffer, pipelineBindPoint,
+                                                        layout, set);
+}
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void VkDecoderSnapshot::vkGetBufferOpaqueCaptureDescriptorDataEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo,
+    void* pData) {
+    mImpl->vkGetBufferOpaqueCaptureDescriptorDataEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                     input_result, device, pInfo, pData);
+}
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void VkDecoderSnapshot::vkGetImageOpaqueCaptureDescriptorDataEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo,
+    void* pData) {
+    mImpl->vkGetImageOpaqueCaptureDescriptorDataEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                    input_result, device, pInfo, pData);
+}
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void VkDecoderSnapshot::vkGetImageViewOpaqueCaptureDescriptorDataEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo,
+    void* pData) {
+    mImpl->vkGetImageViewOpaqueCaptureDescriptorDataEXT(snapshotTraceBegin, snapshotTraceBytes,
+                                                        pool, input_result, device, pInfo, pData);
+}
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void VkDecoderSnapshot::vkGetSamplerOpaqueCaptureDescriptorDataEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo,
+    void* pData) {
+    mImpl->vkGetSamplerOpaqueCaptureDescriptorDataEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                      input_result, device, pInfo, pData);
+}
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void VkDecoderSnapshot::vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device,
+    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) {
+    mImpl->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
+        snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device, pInfo, pData);
+}
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void VkDecoderSnapshot::vkCmdSetFragmentShadingRateEnumNV(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -9058,6 +10429,28 @@ void VkDecoderSnapshot::vkCmdSetFragmentShadingRateEnumNV(
                                              commandBuffer, shadingRate, combinerOps);
 }
 #endif
+#ifdef VK_EXT_image_compression_control
+void VkDecoderSnapshot::vkGetImageSubresourceLayout2EXT(const uint8_t* snapshotTraceBegin,
+                                                        size_t snapshotTraceBytes,
+                                                        android::base::BumpPool* pool,
+                                                        VkDevice device, VkImage image,
+                                                        const VkImageSubresource2EXT* pSubresource,
+                                                        VkSubresourceLayout2EXT* pLayout) {
+    mImpl->vkGetImageSubresourceLayout2EXT(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                           image, pSubresource, pLayout);
+}
+#endif
+#ifdef VK_EXT_device_fault
+void VkDecoderSnapshot::vkGetDeviceFaultInfoEXT(const uint8_t* snapshotTraceBegin,
+                                                size_t snapshotTraceBytes,
+                                                android::base::BumpPool* pool,
+                                                VkResult input_result, VkDevice device,
+                                                VkDeviceFaultCountsEXT* pFaultCounts,
+                                                VkDeviceFaultInfoEXT* pFaultInfo) {
+    mImpl->vkGetDeviceFaultInfoEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+                                   device, pFaultCounts, pFaultInfo);
+}
+#endif
 #ifdef VK_NV_acquire_winrt_display
 void VkDecoderSnapshot::vkAcquireWinrtDisplayNV(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -9234,6 +10627,17 @@ void VkDecoderSnapshot::vkGetMemoryRemoteAddressNV(
                                       device, pMemoryGetRemoteAddressInfo, pAddress);
 }
 #endif
+#ifdef VK_EXT_pipeline_properties
+void VkDecoderSnapshot::vkGetPipelinePropertiesEXT(const uint8_t* snapshotTraceBegin,
+                                                   size_t snapshotTraceBytes,
+                                                   android::base::BumpPool* pool,
+                                                   VkResult input_result, VkDevice device,
+                                                   const VkPipelineInfoEXT* pPipelineInfo,
+                                                   VkBaseOutStructure* pPipelineProperties) {
+    mImpl->vkGetPipelinePropertiesEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+                                      device, pPipelineInfo, pPipelineProperties);
+}
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void VkDecoderSnapshot::vkCmdSetPatchControlPointsEXT(const uint8_t* snapshotTraceBegin,
                                                       size_t snapshotTraceBytes,
@@ -9526,6 +10930,23 @@ void VkDecoderSnapshot::vkGetBlobGOOGLE(const uint8_t* snapshotTraceBegin,
                            memory);
 }
 #endif
+#ifdef VK_GOOGLE_gfxstream
+void VkDecoderSnapshot::vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkDevice device, VkDescriptorSet descriptorSet,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+    uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
+    const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
+    const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
+    const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
+    const uint8_t* pInlineUniformBlockData) {
+    mImpl->vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+        snapshotTraceBegin, snapshotTraceBytes, pool, device, descriptorSet,
+        descriptorUpdateTemplate, imageInfoCount, bufferInfoCount, bufferViewCount,
+        inlineUniformBlockCount, pImageInfoEntryIndices, pBufferInfoEntryIndices,
+        pBufferViewEntryIndices, pImageInfos, pBufferInfos, pBufferViews, pInlineUniformBlockData);
+}
+#endif
 #ifdef VK_EXT_multi_draw
 void VkDecoderSnapshot::vkCmdDrawMultiEXT(const uint8_t* snapshotTraceBegin,
                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -9547,6 +10968,165 @@ void VkDecoderSnapshot::vkCmdDrawMultiIndexedEXT(
                                     pVertexOffset);
 }
 #endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkCreateMicromapEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) {
+    mImpl->vkCreateMicromapEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device,
+                               pCreateInfo, pAllocator, pMicromap);
+}
+#endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkDestroyMicromapEXT(const uint8_t* snapshotTraceBegin,
+                                             size_t snapshotTraceBytes,
+                                             android::base::BumpPool* pool, VkDevice device,
+                                             VkMicromapEXT micromap,
+                                             const VkAllocationCallbacks* pAllocator) {
+    mImpl->vkDestroyMicromapEXT(snapshotTraceBegin, snapshotTraceBytes, pool, device, micromap,
+                                pAllocator);
+}
+#endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkCmdBuildMicromapsEXT(const uint8_t* snapshotTraceBegin,
+                                               size_t snapshotTraceBytes,
+                                               android::base::BumpPool* pool,
+                                               VkCommandBuffer commandBuffer, uint32_t infoCount,
+                                               const VkMicromapBuildInfoEXT* pInfos) {
+    mImpl->vkCmdBuildMicromapsEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                  infoCount, pInfos);
+}
+#endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkBuildMicromapsEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, VkDeferredOperationKHR deferredOperation,
+    uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) {
+    mImpl->vkBuildMicromapsEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device,
+                               deferredOperation, infoCount, pInfos);
+}
+#endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkCopyMicromapEXT(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkResult input_result, VkDevice device,
+                                          VkDeferredOperationKHR deferredOperation,
+                                          const VkCopyMicromapInfoEXT* pInfo) {
+    mImpl->vkCopyMicromapEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device,
+                             deferredOperation, pInfo);
+}
+#endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkCopyMicromapToMemoryEXT(const uint8_t* snapshotTraceBegin,
+                                                  size_t snapshotTraceBytes,
+                                                  android::base::BumpPool* pool,
+                                                  VkResult input_result, VkDevice device,
+                                                  VkDeferredOperationKHR deferredOperation,
+                                                  const VkCopyMicromapToMemoryInfoEXT* pInfo) {
+    mImpl->vkCopyMicromapToMemoryEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+                                     device, deferredOperation, pInfo);
+}
+#endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkCopyMemoryToMicromapEXT(const uint8_t* snapshotTraceBegin,
+                                                  size_t snapshotTraceBytes,
+                                                  android::base::BumpPool* pool,
+                                                  VkResult input_result, VkDevice device,
+                                                  VkDeferredOperationKHR deferredOperation,
+                                                  const VkCopyMemoryToMicromapInfoEXT* pInfo) {
+    mImpl->vkCopyMemoryToMicromapEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+                                     device, deferredOperation, pInfo);
+}
+#endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkWriteMicromapsPropertiesEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps,
+    VkQueryType queryType, size_t dataSize, void* pData, size_t stride) {
+    mImpl->vkWriteMicromapsPropertiesEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+                                         device, micromapCount, pMicromaps, queryType, dataSize,
+                                         pData, stride);
+}
+#endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkCmdCopyMicromapEXT(const uint8_t* snapshotTraceBegin,
+                                             size_t snapshotTraceBytes,
+                                             android::base::BumpPool* pool,
+                                             VkCommandBuffer commandBuffer,
+                                             const VkCopyMicromapInfoEXT* pInfo) {
+    mImpl->vkCmdCopyMicromapEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer, pInfo);
+}
+#endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkCmdCopyMicromapToMemoryEXT(const uint8_t* snapshotTraceBegin,
+                                                     size_t snapshotTraceBytes,
+                                                     android::base::BumpPool* pool,
+                                                     VkCommandBuffer commandBuffer,
+                                                     const VkCopyMicromapToMemoryInfoEXT* pInfo) {
+    mImpl->vkCmdCopyMicromapToMemoryEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                        pInfo);
+}
+#endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkCmdCopyMemoryToMicromapEXT(const uint8_t* snapshotTraceBegin,
+                                                     size_t snapshotTraceBytes,
+                                                     android::base::BumpPool* pool,
+                                                     VkCommandBuffer commandBuffer,
+                                                     const VkCopyMemoryToMicromapInfoEXT* pInfo) {
+    mImpl->vkCmdCopyMemoryToMicromapEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                        pInfo);
+}
+#endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkCmdWriteMicromapsPropertiesEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps,
+    VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) {
+    mImpl->vkCmdWriteMicromapsPropertiesEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                            commandBuffer, micromapCount, pMicromaps, queryType,
+                                            queryPool, firstQuery);
+}
+#endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkGetDeviceMicromapCompatibilityEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo,
+    VkAccelerationStructureCompatibilityKHR* pCompatibility) {
+    mImpl->vkGetDeviceMicromapCompatibilityEXT(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                               pVersionInfo, pCompatibility);
+}
+#endif
+#ifdef VK_EXT_opacity_micromap
+void VkDecoderSnapshot::vkGetMicromapBuildSizesEXT(const uint8_t* snapshotTraceBegin,
+                                                   size_t snapshotTraceBytes,
+                                                   android::base::BumpPool* pool, VkDevice device,
+                                                   VkAccelerationStructureBuildTypeKHR buildType,
+                                                   const VkMicromapBuildInfoEXT* pBuildInfo,
+                                                   VkMicromapBuildSizesInfoEXT* pSizeInfo) {
+    mImpl->vkGetMicromapBuildSizesEXT(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                      buildType, pBuildInfo, pSizeInfo);
+}
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void VkDecoderSnapshot::vkCmdDrawClusterHUAWEI(const uint8_t* snapshotTraceBegin,
+                                               size_t snapshotTraceBytes,
+                                               android::base::BumpPool* pool,
+                                               VkCommandBuffer commandBuffer, uint32_t groupCountX,
+                                               uint32_t groupCountY, uint32_t groupCountZ) {
+    mImpl->vkCmdDrawClusterHUAWEI(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                  groupCountX, groupCountY, groupCountZ);
+}
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void VkDecoderSnapshot::vkCmdDrawClusterIndirectHUAWEI(const uint8_t* snapshotTraceBegin,
+                                                       size_t snapshotTraceBytes,
+                                                       android::base::BumpPool* pool,
+                                                       VkCommandBuffer commandBuffer,
+                                                       VkBuffer buffer, VkDeviceSize offset) {
+    mImpl->vkCmdDrawClusterIndirectHUAWEI(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                          commandBuffer, buffer, offset);
+}
+#endif
 #ifdef VK_EXT_pageable_device_local_memory
 void VkDecoderSnapshot::vkSetDeviceMemoryPriorityEXT(const uint8_t* snapshotTraceBegin,
                                                      size_t snapshotTraceBytes,
@@ -9556,6 +11136,494 @@ void VkDecoderSnapshot::vkSetDeviceMemoryPriorityEXT(const uint8_t* snapshotTrac
                                         memory, priority);
 }
 #endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void VkDecoderSnapshot::vkGetDescriptorSetLayoutHostMappingInfoVALVE(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference,
+    VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) {
+    mImpl->vkGetDescriptorSetLayoutHostMappingInfoVALVE(
+        snapshotTraceBegin, snapshotTraceBytes, pool, device, pBindingReference, pHostMapping);
+}
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void VkDecoderSnapshot::vkGetDescriptorSetHostMappingVALVE(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkDevice device, VkDescriptorSet descriptorSet, void** ppData) {
+    mImpl->vkGetDescriptorSetHostMappingVALVE(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                              descriptorSet, ppData);
+}
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void VkDecoderSnapshot::vkCmdCopyMemoryIndirectNV(const uint8_t* snapshotTraceBegin,
+                                                  size_t snapshotTraceBytes,
+                                                  android::base::BumpPool* pool,
+                                                  VkCommandBuffer commandBuffer,
+                                                  VkDeviceAddress copyBufferAddress,
+                                                  uint32_t copyCount, uint32_t stride) {
+    mImpl->vkCmdCopyMemoryIndirectNV(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                     copyBufferAddress, copyCount, stride);
+}
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void VkDecoderSnapshot::vkCmdCopyMemoryToImageIndirectNV(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount,
+    uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout,
+    const VkImageSubresourceLayers* pImageSubresources) {
+    mImpl->vkCmdCopyMemoryToImageIndirectNV(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                            commandBuffer, copyBufferAddress, copyCount, stride,
+                                            dstImage, dstImageLayout, pImageSubresources);
+}
+#endif
+#ifdef VK_NV_memory_decompression
+void VkDecoderSnapshot::vkCmdDecompressMemoryNV(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, uint32_t decompressRegionCount,
+    const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) {
+    mImpl->vkCmdDecompressMemoryNV(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                   decompressRegionCount, pDecompressMemoryRegions);
+}
+#endif
+#ifdef VK_NV_memory_decompression
+void VkDecoderSnapshot::vkCmdDecompressMemoryIndirectCountNV(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress,
+    VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) {
+    mImpl->vkCmdDecompressMemoryIndirectCountNV(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                commandBuffer, indirectCommandsAddress,
+                                                indirectCommandsCountAddress, stride);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetTessellationDomainOriginEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin) {
+    mImpl->vkCmdSetTessellationDomainOriginEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                               commandBuffer, domainOrigin);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetDepthClampEnableEXT(const uint8_t* snapshotTraceBegin,
+                                                    size_t snapshotTraceBytes,
+                                                    android::base::BumpPool* pool,
+                                                    VkCommandBuffer commandBuffer,
+                                                    VkBool32 depthClampEnable) {
+    mImpl->vkCmdSetDepthClampEnableEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                       depthClampEnable);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetPolygonModeEXT(const uint8_t* snapshotTraceBegin,
+                                               size_t snapshotTraceBytes,
+                                               android::base::BumpPool* pool,
+                                               VkCommandBuffer commandBuffer,
+                                               VkPolygonMode polygonMode) {
+    mImpl->vkCmdSetPolygonModeEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                  polygonMode);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetRasterizationSamplesEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) {
+    mImpl->vkCmdSetRasterizationSamplesEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                           commandBuffer, rasterizationSamples);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetSampleMaskEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) {
+    mImpl->vkCmdSetSampleMaskEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                 samples, pSampleMask);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetAlphaToCoverageEnableEXT(const uint8_t* snapshotTraceBegin,
+                                                         size_t snapshotTraceBytes,
+                                                         android::base::BumpPool* pool,
+                                                         VkCommandBuffer commandBuffer,
+                                                         VkBool32 alphaToCoverageEnable) {
+    mImpl->vkCmdSetAlphaToCoverageEnableEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                            commandBuffer, alphaToCoverageEnable);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetAlphaToOneEnableEXT(const uint8_t* snapshotTraceBegin,
+                                                    size_t snapshotTraceBytes,
+                                                    android::base::BumpPool* pool,
+                                                    VkCommandBuffer commandBuffer,
+                                                    VkBool32 alphaToOneEnable) {
+    mImpl->vkCmdSetAlphaToOneEnableEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                       alphaToOneEnable);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetLogicOpEnableEXT(const uint8_t* snapshotTraceBegin,
+                                                 size_t snapshotTraceBytes,
+                                                 android::base::BumpPool* pool,
+                                                 VkCommandBuffer commandBuffer,
+                                                 VkBool32 logicOpEnable) {
+    mImpl->vkCmdSetLogicOpEnableEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                    logicOpEnable);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetColorBlendEnableEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount,
+    const VkBool32* pColorBlendEnables) {
+    mImpl->vkCmdSetColorBlendEnableEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                       firstAttachment, attachmentCount, pColorBlendEnables);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetColorBlendEquationEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount,
+    const VkColorBlendEquationEXT* pColorBlendEquations) {
+    mImpl->vkCmdSetColorBlendEquationEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                         commandBuffer, firstAttachment, attachmentCount,
+                                         pColorBlendEquations);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetColorWriteMaskEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount,
+    const VkColorComponentFlags* pColorWriteMasks) {
+    mImpl->vkCmdSetColorWriteMaskEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                     firstAttachment, attachmentCount, pColorWriteMasks);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetRasterizationStreamEXT(const uint8_t* snapshotTraceBegin,
+                                                       size_t snapshotTraceBytes,
+                                                       android::base::BumpPool* pool,
+                                                       VkCommandBuffer commandBuffer,
+                                                       uint32_t rasterizationStream) {
+    mImpl->vkCmdSetRasterizationStreamEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                          commandBuffer, rasterizationStream);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetConservativeRasterizationModeEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer,
+    VkConservativeRasterizationModeEXT conservativeRasterizationMode) {
+    mImpl->vkCmdSetConservativeRasterizationModeEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                    commandBuffer, conservativeRasterizationMode);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetExtraPrimitiveOverestimationSizeEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) {
+    mImpl->vkCmdSetExtraPrimitiveOverestimationSizeEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                       commandBuffer,
+                                                       extraPrimitiveOverestimationSize);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetDepthClipEnableEXT(const uint8_t* snapshotTraceBegin,
+                                                   size_t snapshotTraceBytes,
+                                                   android::base::BumpPool* pool,
+                                                   VkCommandBuffer commandBuffer,
+                                                   VkBool32 depthClipEnable) {
+    mImpl->vkCmdSetDepthClipEnableEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                      depthClipEnable);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetSampleLocationsEnableEXT(const uint8_t* snapshotTraceBegin,
+                                                         size_t snapshotTraceBytes,
+                                                         android::base::BumpPool* pool,
+                                                         VkCommandBuffer commandBuffer,
+                                                         VkBool32 sampleLocationsEnable) {
+    mImpl->vkCmdSetSampleLocationsEnableEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                            commandBuffer, sampleLocationsEnable);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetColorBlendAdvancedEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount,
+    const VkColorBlendAdvancedEXT* pColorBlendAdvanced) {
+    mImpl->vkCmdSetColorBlendAdvancedEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                         commandBuffer, firstAttachment, attachmentCount,
+                                         pColorBlendAdvanced);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetProvokingVertexModeEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) {
+    mImpl->vkCmdSetProvokingVertexModeEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                          commandBuffer, provokingVertexMode);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetLineRasterizationModeEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) {
+    mImpl->vkCmdSetLineRasterizationModeEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                            commandBuffer, lineRasterizationMode);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetLineStippleEnableEXT(const uint8_t* snapshotTraceBegin,
+                                                     size_t snapshotTraceBytes,
+                                                     android::base::BumpPool* pool,
+                                                     VkCommandBuffer commandBuffer,
+                                                     VkBool32 stippledLineEnable) {
+    mImpl->vkCmdSetLineStippleEnableEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                        stippledLineEnable);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetDepthClipNegativeOneToOneEXT(const uint8_t* snapshotTraceBegin,
+                                                             size_t snapshotTraceBytes,
+                                                             android::base::BumpPool* pool,
+                                                             VkCommandBuffer commandBuffer,
+                                                             VkBool32 negativeOneToOne) {
+    mImpl->vkCmdSetDepthClipNegativeOneToOneEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                commandBuffer, negativeOneToOne);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetViewportWScalingEnableNV(const uint8_t* snapshotTraceBegin,
+                                                         size_t snapshotTraceBytes,
+                                                         android::base::BumpPool* pool,
+                                                         VkCommandBuffer commandBuffer,
+                                                         VkBool32 viewportWScalingEnable) {
+    mImpl->vkCmdSetViewportWScalingEnableNV(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                            commandBuffer, viewportWScalingEnable);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetViewportSwizzleNV(const uint8_t* snapshotTraceBegin,
+                                                  size_t snapshotTraceBytes,
+                                                  android::base::BumpPool* pool,
+                                                  VkCommandBuffer commandBuffer,
+                                                  uint32_t firstViewport, uint32_t viewportCount,
+                                                  const VkViewportSwizzleNV* pViewportSwizzles) {
+    mImpl->vkCmdSetViewportSwizzleNV(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                     firstViewport, viewportCount, pViewportSwizzles);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetCoverageToColorEnableNV(const uint8_t* snapshotTraceBegin,
+                                                        size_t snapshotTraceBytes,
+                                                        android::base::BumpPool* pool,
+                                                        VkCommandBuffer commandBuffer,
+                                                        VkBool32 coverageToColorEnable) {
+    mImpl->vkCmdSetCoverageToColorEnableNV(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                           commandBuffer, coverageToColorEnable);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetCoverageToColorLocationNV(const uint8_t* snapshotTraceBegin,
+                                                          size_t snapshotTraceBytes,
+                                                          android::base::BumpPool* pool,
+                                                          VkCommandBuffer commandBuffer,
+                                                          uint32_t coverageToColorLocation) {
+    mImpl->vkCmdSetCoverageToColorLocationNV(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                             commandBuffer, coverageToColorLocation);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetCoverageModulationModeNV(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) {
+    mImpl->vkCmdSetCoverageModulationModeNV(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                            commandBuffer, coverageModulationMode);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetCoverageModulationTableEnableNV(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) {
+    mImpl->vkCmdSetCoverageModulationTableEnableNV(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                   commandBuffer, coverageModulationTableEnable);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetCoverageModulationTableNV(const uint8_t* snapshotTraceBegin,
+                                                          size_t snapshotTraceBytes,
+                                                          android::base::BumpPool* pool,
+                                                          VkCommandBuffer commandBuffer,
+                                                          uint32_t coverageModulationTableCount,
+                                                          const float* pCoverageModulationTable) {
+    mImpl->vkCmdSetCoverageModulationTableNV(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                             commandBuffer, coverageModulationTableCount,
+                                             pCoverageModulationTable);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetShadingRateImageEnableNV(const uint8_t* snapshotTraceBegin,
+                                                         size_t snapshotTraceBytes,
+                                                         android::base::BumpPool* pool,
+                                                         VkCommandBuffer commandBuffer,
+                                                         VkBool32 shadingRateImageEnable) {
+    mImpl->vkCmdSetShadingRateImageEnableNV(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                            commandBuffer, shadingRateImageEnable);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetRepresentativeFragmentTestEnableNV(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) {
+    mImpl->vkCmdSetRepresentativeFragmentTestEnableNV(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                      commandBuffer,
+                                                      representativeFragmentTestEnable);
+}
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void VkDecoderSnapshot::vkCmdSetCoverageReductionModeNV(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) {
+    mImpl->vkCmdSetCoverageReductionModeNV(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                           commandBuffer, coverageReductionMode);
+}
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void VkDecoderSnapshot::vkGetShaderModuleIdentifierEXT(const uint8_t* snapshotTraceBegin,
+                                                       size_t snapshotTraceBytes,
+                                                       android::base::BumpPool* pool,
+                                                       VkDevice device, VkShaderModule shaderModule,
+                                                       VkShaderModuleIdentifierEXT* pIdentifier) {
+    mImpl->vkGetShaderModuleIdentifierEXT(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                          shaderModule, pIdentifier);
+}
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void VkDecoderSnapshot::vkGetShaderModuleCreateInfoIdentifierEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo,
+    VkShaderModuleIdentifierEXT* pIdentifier) {
+    mImpl->vkGetShaderModuleCreateInfoIdentifierEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                    device, pCreateInfo, pIdentifier);
+}
+#endif
+#ifdef VK_NV_optical_flow
+void VkDecoderSnapshot::vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkPhysicalDevice physicalDevice,
+    const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount,
+    VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) {
+    mImpl->vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
+        snapshotTraceBegin, snapshotTraceBytes, pool, input_result, physicalDevice,
+        pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties);
+}
+#endif
+#ifdef VK_NV_optical_flow
+void VkDecoderSnapshot::vkCreateOpticalFlowSessionNV(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo,
+    const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) {
+    mImpl->vkCreateOpticalFlowSessionNV(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+                                        device, pCreateInfo, pAllocator, pSession);
+}
+#endif
+#ifdef VK_NV_optical_flow
+void VkDecoderSnapshot::vkDestroyOpticalFlowSessionNV(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) {
+    mImpl->vkDestroyOpticalFlowSessionNV(snapshotTraceBegin, snapshotTraceBytes, pool, device,
+                                         session, pAllocator);
+}
+#endif
+#ifdef VK_NV_optical_flow
+void VkDecoderSnapshot::vkBindOpticalFlowSessionImageNV(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, VkOpticalFlowSessionNV session,
+    VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) {
+    mImpl->vkBindOpticalFlowSessionImageNV(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                           input_result, device, session, bindingPoint, view,
+                                           layout);
+}
+#endif
+#ifdef VK_NV_optical_flow
+void VkDecoderSnapshot::vkCmdOpticalFlowExecuteNV(const uint8_t* snapshotTraceBegin,
+                                                  size_t snapshotTraceBytes,
+                                                  android::base::BumpPool* pool,
+                                                  VkCommandBuffer commandBuffer,
+                                                  VkOpticalFlowSessionNV session,
+                                                  const VkOpticalFlowExecuteInfoNV* pExecuteInfo) {
+    mImpl->vkCmdOpticalFlowExecuteNV(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                     session, pExecuteInfo);
+}
+#endif
+#ifdef VK_EXT_shader_object
+void VkDecoderSnapshot::vkCreateShadersEXT(const uint8_t* snapshotTraceBegin,
+                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                           VkResult input_result, VkDevice device,
+                                           uint32_t createInfoCount,
+                                           const VkShaderCreateInfoEXT* pCreateInfos,
+                                           const VkAllocationCallbacks* pAllocator,
+                                           VkShaderEXT* pShaders) {
+    mImpl->vkCreateShadersEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result, device,
+                              createInfoCount, pCreateInfos, pAllocator, pShaders);
+}
+#endif
+#ifdef VK_EXT_shader_object
+void VkDecoderSnapshot::vkDestroyShaderEXT(const uint8_t* snapshotTraceBegin,
+                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                           VkDevice device, VkShaderEXT shader,
+                                           const VkAllocationCallbacks* pAllocator) {
+    mImpl->vkDestroyShaderEXT(snapshotTraceBegin, snapshotTraceBytes, pool, device, shader,
+                              pAllocator);
+}
+#endif
+#ifdef VK_EXT_shader_object
+void VkDecoderSnapshot::vkGetShaderBinaryDataEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData) {
+    mImpl->vkGetShaderBinaryDataEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+                                    device, shader, pDataSize, pData);
+}
+#endif
+#ifdef VK_EXT_shader_object
+void VkDecoderSnapshot::vkCmdBindShadersEXT(const uint8_t* snapshotTraceBegin,
+                                            size_t snapshotTraceBytes,
+                                            android::base::BumpPool* pool,
+                                            VkCommandBuffer commandBuffer, uint32_t stageCount,
+                                            const VkShaderStageFlagBits* pStages,
+                                            const VkShaderEXT* pShaders) {
+    mImpl->vkCmdBindShadersEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                               stageCount, pStages, pShaders);
+}
+#endif
+#ifdef VK_QCOM_tile_properties
+void VkDecoderSnapshot::vkGetFramebufferTilePropertiesQCOM(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount,
+    VkTilePropertiesQCOM* pProperties) {
+    mImpl->vkGetFramebufferTilePropertiesQCOM(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                              input_result, device, framebuffer, pPropertiesCount,
+                                              pProperties);
+}
+#endif
+#ifdef VK_QCOM_tile_properties
+void VkDecoderSnapshot::vkGetDynamicRenderingTilePropertiesQCOM(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkResult input_result, VkDevice device, const VkRenderingInfo* pRenderingInfo,
+    VkTilePropertiesQCOM* pProperties) {
+    mImpl->vkGetDynamicRenderingTilePropertiesQCOM(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                   input_result, device, pRenderingInfo,
+                                                   pProperties);
+}
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+void VkDecoderSnapshot::vkCmdSetAttachmentFeedbackLoopEnableEXT(const uint8_t* snapshotTraceBegin,
+                                                                size_t snapshotTraceBytes,
+                                                                android::base::BumpPool* pool,
+                                                                VkCommandBuffer commandBuffer,
+                                                                VkImageAspectFlags aspectMask) {
+    mImpl->vkCmdSetAttachmentFeedbackLoopEnableEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                                   commandBuffer, aspectMask);
+}
+#endif
 #ifdef VK_KHR_acceleration_structure
 void VkDecoderSnapshot::vkCreateAccelerationStructureKHR(
     const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -9780,3 +11848,34 @@ void VkDecoderSnapshot::vkCmdSetRayTracingPipelineStackSizeKHR(const uint8_t* sn
                                                   commandBuffer, pipelineStackSize);
 }
 #endif
+#ifdef VK_EXT_mesh_shader
+void VkDecoderSnapshot::vkCmdDrawMeshTasksEXT(const uint8_t* snapshotTraceBegin,
+                                              size_t snapshotTraceBytes,
+                                              android::base::BumpPool* pool,
+                                              VkCommandBuffer commandBuffer, uint32_t groupCountX,
+                                              uint32_t groupCountY, uint32_t groupCountZ) {
+    mImpl->vkCmdDrawMeshTasksEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+                                 groupCountX, groupCountY, groupCountZ);
+}
+#endif
+#ifdef VK_EXT_mesh_shader
+void VkDecoderSnapshot::vkCmdDrawMeshTasksIndirectEXT(const uint8_t* snapshotTraceBegin,
+                                                      size_t snapshotTraceBytes,
+                                                      android::base::BumpPool* pool,
+                                                      VkCommandBuffer commandBuffer,
+                                                      VkBuffer buffer, VkDeviceSize offset,
+                                                      uint32_t drawCount, uint32_t stride) {
+    mImpl->vkCmdDrawMeshTasksIndirectEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                         commandBuffer, buffer, offset, drawCount, stride);
+}
+#endif
+#ifdef VK_EXT_mesh_shader
+void VkDecoderSnapshot::vkCmdDrawMeshTasksIndirectCountEXT(
+    const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+    VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer,
+    VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {
+    mImpl->vkCmdDrawMeshTasksIndirectCountEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+                                              commandBuffer, buffer, offset, countBuffer,
+                                              countBufferOffset, maxDrawCount, stride);
+}
+#endif
diff --git a/stream-servers/vulkan/VkDecoderSnapshot.h b/stream-servers/vulkan/VkDecoderSnapshot.h
index 37a62cc8..0f2bb6ec 100644
--- a/stream-servers/vulkan/VkDecoderSnapshot.h
+++ b/stream-servers/vulkan/VkDecoderSnapshot.h
@@ -15,8 +15,8 @@
 
 // Autogenerated module VkDecoderSnapshot
 //
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (header) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -762,6 +762,137 @@ class VkDecoderSnapshot {
                                                VkDevice device,
                                                const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
 #endif
+#ifdef VK_VERSION_1_3
+    void vkGetPhysicalDeviceToolProperties(const uint8_t* snapshotTraceBegin,
+                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                           VkResult input_result, VkPhysicalDevice physicalDevice,
+                                           uint32_t* pToolCount,
+                                           VkPhysicalDeviceToolProperties* pToolProperties);
+    void vkCreatePrivateDataSlot(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkResult input_result,
+                                 VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
+                                 const VkAllocationCallbacks* pAllocator,
+                                 VkPrivateDataSlot* pPrivateDataSlot);
+    void vkDestroyPrivateDataSlot(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                  android::base::BumpPool* pool, VkDevice device,
+                                  VkPrivateDataSlot privateDataSlot,
+                                  const VkAllocationCallbacks* pAllocator);
+    void vkSetPrivateData(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                          android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                          VkObjectType objectType, uint64_t objectHandle,
+                          VkPrivateDataSlot privateDataSlot, uint64_t data);
+    void vkGetPrivateData(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                          android::base::BumpPool* pool, VkDevice device, VkObjectType objectType,
+                          uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
+                          uint64_t* pData);
+    void vkCmdSetEvent2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                        android::base::BumpPool* pool, VkCommandBuffer commandBuffer, VkEvent event,
+                        const VkDependencyInfo* pDependencyInfo);
+    void vkCmdResetEvent2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                          android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                          VkEvent event, VkPipelineStageFlags2 stageMask);
+    void vkCmdWaitEvents2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                          android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                          uint32_t eventCount, const VkEvent* pEvents,
+                          const VkDependencyInfo* pDependencyInfos);
+    void vkCmdPipelineBarrier2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                               android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                               const VkDependencyInfo* pDependencyInfo);
+    void vkCmdWriteTimestamp2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                              android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                              VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query);
+    void vkQueueSubmit2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                        android::base::BumpPool* pool, VkResult input_result, VkQueue queue,
+                        uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);
+    void vkCmdCopyBuffer2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                          android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                          const VkCopyBufferInfo2* pCopyBufferInfo);
+    void vkCmdCopyImage2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                         android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                         const VkCopyImageInfo2* pCopyImageInfo);
+    void vkCmdCopyBufferToImage2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                 const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);
+    void vkCmdCopyImageToBuffer2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                 const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);
+    void vkCmdBlitImage2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                         android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                         const VkBlitImageInfo2* pBlitImageInfo);
+    void vkCmdResolveImage2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                            android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                            const VkResolveImageInfo2* pResolveImageInfo);
+    void vkCmdBeginRendering(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                             android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                             const VkRenderingInfo* pRenderingInfo);
+    void vkCmdEndRendering(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                           android::base::BumpPool* pool, VkCommandBuffer commandBuffer);
+    void vkCmdSetCullMode(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                          android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                          VkCullModeFlags cullMode);
+    void vkCmdSetFrontFace(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                           android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                           VkFrontFace frontFace);
+    void vkCmdSetPrimitiveTopology(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   VkPrimitiveTopology primitiveTopology);
+    void vkCmdSetViewportWithCount(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   uint32_t viewportCount, const VkViewport* pViewports);
+    void vkCmdSetScissorWithCount(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                  android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                  uint32_t scissorCount, const VkRect2D* pScissors);
+    void vkCmdBindVertexBuffers2(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                 uint32_t firstBinding, uint32_t bindingCount,
+                                 const VkBuffer* pBuffers, const VkDeviceSize* pOffsets,
+                                 const VkDeviceSize* pSizes, const VkDeviceSize* pStrides);
+    void vkCmdSetDepthTestEnable(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                 VkBool32 depthTestEnable);
+    void vkCmdSetDepthWriteEnable(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                  android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                  VkBool32 depthWriteEnable);
+    void vkCmdSetDepthCompareOp(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                VkCompareOp depthCompareOp);
+    void vkCmdSetDepthBoundsTestEnable(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                       VkBool32 depthBoundsTestEnable);
+    void vkCmdSetStencilTestEnable(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   VkBool32 stencilTestEnable);
+    void vkCmdSetStencilOp(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                           android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                           VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp,
+                           VkStencilOp depthFailOp, VkCompareOp compareOp);
+    void vkCmdSetRasterizerDiscardEnable(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer,
+                                         VkBool32 rasterizerDiscardEnable);
+    void vkCmdSetDepthBiasEnable(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                 VkBool32 depthBiasEnable);
+    void vkCmdSetPrimitiveRestartEnable(const uint8_t* snapshotTraceBegin,
+                                        size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                        VkCommandBuffer commandBuffer,
+                                        VkBool32 primitiveRestartEnable);
+    void vkGetDeviceBufferMemoryRequirements(const uint8_t* snapshotTraceBegin,
+                                             size_t snapshotTraceBytes,
+                                             android::base::BumpPool* pool, VkDevice device,
+                                             const VkDeviceBufferMemoryRequirements* pInfo,
+                                             VkMemoryRequirements2* pMemoryRequirements);
+    void vkGetDeviceImageMemoryRequirements(const uint8_t* snapshotTraceBegin,
+                                            size_t snapshotTraceBytes,
+                                            android::base::BumpPool* pool, VkDevice device,
+                                            const VkDeviceImageMemoryRequirements* pInfo,
+                                            VkMemoryRequirements2* pMemoryRequirements);
+    void vkGetDeviceImageSparseMemoryRequirements(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
+        uint32_t* pSparseMemoryRequirementCount,
+        VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
+#endif
 #ifdef VK_KHR_surface
     void vkDestroySurfaceKHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkInstance instance,
@@ -923,7 +1054,7 @@ class VkDecoderSnapshot {
     void vkGetPhysicalDeviceVideoCapabilitiesKHR(
         const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
         VkResult input_result, VkPhysicalDevice physicalDevice,
-        const VkVideoProfileKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities);
+        const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities);
     void vkGetPhysicalDeviceVideoFormatPropertiesKHR(
         const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
         VkResult input_result, VkPhysicalDevice physicalDevice,
@@ -941,13 +1072,13 @@ class VkDecoderSnapshot {
     void vkGetVideoSessionMemoryRequirementsKHR(
         const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
         VkResult input_result, VkDevice device, VkVideoSessionKHR videoSession,
-        uint32_t* pVideoSessionMemoryRequirementsCount,
-        VkVideoGetMemoryPropertiesKHR* pVideoSessionMemoryRequirements);
-    void vkBindVideoSessionMemoryKHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                                     android::base::BumpPool* pool, VkResult input_result,
-                                     VkDevice device, VkVideoSessionKHR videoSession,
-                                     uint32_t videoSessionBindMemoryCount,
-                                     const VkVideoBindMemoryKHR* pVideoSessionBindMemories);
+        uint32_t* pMemoryRequirementsCount,
+        VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements);
+    void vkBindVideoSessionMemoryKHR(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkDevice device, VkVideoSessionKHR videoSession,
+        uint32_t bindSessionMemoryInfoCount,
+        const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos);
     void vkCreateVideoSessionParametersKHR(const uint8_t* snapshotTraceBegin,
                                            size_t snapshotTraceBytes, android::base::BumpPool* pool,
                                            VkResult input_result, VkDevice device,
@@ -976,12 +1107,14 @@ class VkDecoderSnapshot {
 #ifdef VK_KHR_video_decode_queue
     void vkCmdDecodeVideoKHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                             const VkVideoDecodeInfoKHR* pFrameInfo);
+                             const VkVideoDecodeInfoKHR* pDecodeInfo);
+#endif
+#ifdef VK_KHR_video_decode_h264
 #endif
 #ifdef VK_KHR_dynamic_rendering
     void vkCmdBeginRenderingKHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                                const VkRenderingInfoKHR* pRenderingInfo);
+                                const VkRenderingInfo* pRenderingInfo);
     void vkCmdEndRenderingKHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                               android::base::BumpPool* pool, VkCommandBuffer commandBuffer);
 #endif
@@ -1327,6 +1460,10 @@ class VkDecoderSnapshot {
 #endif
 #ifdef VK_KHR_shader_clock
 #endif
+#ifdef VK_KHR_video_decode_h265
+#endif
+#ifdef VK_KHR_global_priority
+#endif
 #ifdef VK_KHR_driver_properties
 #endif
 #ifdef VK_KHR_shader_float_controls
@@ -1425,6 +1562,14 @@ class VkDecoderSnapshot {
         uint32_t* pInternalRepresentationCount,
         VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
 #endif
+#ifdef VK_KHR_map_memory2
+    void vkMapMemory2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                         android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                         const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData);
+    void vkUnmapMemory2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                           android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                           const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo);
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -1441,33 +1586,35 @@ class VkDecoderSnapshot {
 #ifdef VK_KHR_synchronization2
     void vkCmdSetEvent2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                            android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                           VkEvent event, const VkDependencyInfoKHR* pDependencyInfo);
+                           VkEvent event, const VkDependencyInfo* pDependencyInfo);
     void vkCmdResetEvent2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                             VkEvent event, VkPipelineStageFlags2KHR stageMask);
+                             VkEvent event, VkPipelineStageFlags2 stageMask);
     void vkCmdWaitEvents2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
                              uint32_t eventCount, const VkEvent* pEvents,
-                             const VkDependencyInfoKHR* pDependencyInfos);
+                             const VkDependencyInfo* pDependencyInfos);
     void vkCmdPipelineBarrier2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                                  const VkDependencyInfoKHR* pDependencyInfo);
+                                  const VkDependencyInfo* pDependencyInfo);
     void vkCmdWriteTimestamp2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                  android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                                 VkPipelineStageFlags2KHR stage, VkQueryPool queryPool,
+                                 VkPipelineStageFlags2 stage, VkQueryPool queryPool,
                                  uint32_t query);
     void vkQueueSubmit2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                            android::base::BumpPool* pool, VkResult input_result, VkQueue queue,
-                           uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits, VkFence fence);
+                           uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);
     void vkCmdWriteBufferMarker2AMD(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                                    VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer,
+                                    VkPipelineStageFlags2 stage, VkBuffer dstBuffer,
                                     VkDeviceSize dstOffset, uint32_t marker);
     void vkGetQueueCheckpointData2NV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                      android::base::BumpPool* pool, VkQueue queue,
                                      uint32_t* pCheckpointDataCount,
                                      VkCheckpointData2NV* pCheckpointData);
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
@@ -1477,42 +1624,51 @@ class VkDecoderSnapshot {
 #ifdef VK_KHR_copy_commands2
     void vkCmdCopyBuffer2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                             const VkCopyBufferInfo2KHR* pCopyBufferInfo);
+                             const VkCopyBufferInfo2* pCopyBufferInfo);
     void vkCmdCopyImage2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                             android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                            const VkCopyImageInfo2KHR* pCopyImageInfo);
+                            const VkCopyImageInfo2* pCopyImageInfo);
     void vkCmdCopyBufferToImage2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                                    const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo);
+                                    const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);
     void vkCmdCopyImageToBuffer2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                                    const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo);
+                                    const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);
     void vkCmdBlitImage2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                             android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                            const VkBlitImageInfo2KHR* pBlitImageInfo);
+                            const VkBlitImageInfo2* pBlitImageInfo);
     void vkCmdResolveImage2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
-                               const VkResolveImageInfo2KHR* pResolveImageInfo);
+                               const VkResolveImageInfo2* pResolveImageInfo);
 #endif
 #ifdef VK_KHR_format_feature_flags2
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+    void vkCmdTraceRaysIndirect2KHR(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                    android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                    VkDeviceAddress indirectDeviceAddress);
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
     void vkGetDeviceBufferMemoryRequirementsKHR(const uint8_t* snapshotTraceBegin,
                                                 size_t snapshotTraceBytes,
                                                 android::base::BumpPool* pool, VkDevice device,
-                                                const VkDeviceBufferMemoryRequirementsKHR* pInfo,
+                                                const VkDeviceBufferMemoryRequirements* pInfo,
                                                 VkMemoryRequirements2* pMemoryRequirements);
     void vkGetDeviceImageMemoryRequirementsKHR(const uint8_t* snapshotTraceBegin,
                                                size_t snapshotTraceBytes,
                                                android::base::BumpPool* pool, VkDevice device,
-                                               const VkDeviceImageMemoryRequirementsKHR* pInfo,
+                                               const VkDeviceImageMemoryRequirements* pInfo,
                                                VkMemoryRequirements2* pMemoryRequirements);
     void vkGetDeviceImageSparseMemoryRequirementsKHR(
         const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
-        VkDevice device, const VkDeviceImageMemoryRequirementsKHR* pInfo,
+        VkDevice device, const VkDeviceImageMemoryRequirements* pInfo,
         uint32_t* pSparseMemoryRequirementCount,
         VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);
 #endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+#endif
 #ifdef VK_ANDROID_native_buffer
     void vkGetSwapchainGrallocUsageANDROID(const uint8_t* snapshotTraceBegin,
                                            size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -1528,6 +1684,11 @@ class VkDecoderSnapshot {
                                           uint32_t waitSemaphoreCount,
                                           const VkSemaphore* pWaitSemaphores, VkImage image,
                                           int* pNativeFenceFd);
+    void vkGetSwapchainGrallocUsage2ANDROID(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
+        VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
+        uint64_t* grallocProducerUsage);
 #endif
 #ifdef VK_EXT_debug_report
     void vkCreateDebugReportCallbackEXT(const uint8_t* snapshotTraceBegin,
@@ -1660,8 +1821,6 @@ class VkDecoderSnapshot {
 #endif
 #ifdef VK_EXT_video_encode_h265
 #endif
-#ifdef VK_EXT_video_decode_h264
-#endif
 #ifdef VK_AMD_texture_gather_bias_lod
 #endif
 #ifdef VK_AMD_shader_info
@@ -1717,6 +1876,8 @@ class VkDecoderSnapshot {
 #endif
 #ifdef VK_EXT_astc_decode_mode
 #endif
+#ifdef VK_EXT_pipeline_robustness
+#endif
 #ifdef VK_EXT_conditional_rendering
     void vkCmdBeginConditionalRenderingEXT(
         const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -1800,6 +1961,14 @@ class VkDecoderSnapshot {
                                      android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
                                      uint32_t firstDiscardRectangle, uint32_t discardRectangleCount,
                                      const VkRect2D* pDiscardRectangles);
+    void vkCmdSetDiscardRectangleEnableEXT(const uint8_t* snapshotTraceBegin,
+                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                           VkCommandBuffer commandBuffer,
+                                           VkBool32 discardRectangleEnable);
+    void vkCmdSetDiscardRectangleModeEXT(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer,
+                                         VkDiscardRectangleModeEXT discardRectangleMode);
 #endif
 #ifdef VK_EXT_conservative_rasterization
 #endif
@@ -1826,23 +1995,6 @@ class VkDecoderSnapshot {
                                  const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
                                  const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
 #endif
-#ifdef VK_MVK_moltenvk
-    void vkGetMTLDeviceMVK(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                           android::base::BumpPool* pool, VkPhysicalDevice physicalDevice,
-                           void** pMTLDevice);
-    void vkSetMTLTextureMVK(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                            android::base::BumpPool* pool, VkResult input_result, VkImage image,
-                            void* mtlTexture);
-    void vkGetMTLTextureMVK(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                            android::base::BumpPool* pool, VkImage image, void** pMTLTexture);
-    void vkGetMTLBufferMVK(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                           android::base::BumpPool* pool, VkBuffer buffer, void** pMTLBuffer);
-    void vkUseIOSurfaceMVK(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                           android::base::BumpPool* pool, VkResult input_result, VkImage image,
-                           void* ioSurface);
-    void vkGetIOSurfaceMVK(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
-                           android::base::BumpPool* pool, VkImage image, void** pIOSurface);
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -2088,8 +2240,6 @@ class VkDecoderSnapshot {
 #endif
 #ifdef VK_AMD_shader_core_properties
 #endif
-#ifdef VK_EXT_video_decode_h265
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 #endif
 #ifdef VK_EXT_vertex_attribute_divisor
@@ -2122,6 +2272,12 @@ class VkDecoderSnapshot {
 #ifdef VK_NV_shader_image_footprint
 #endif
 #ifdef VK_NV_scissor_exclusive
+    void vkCmdSetExclusiveScissorEnableNV(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          uint32_t firstExclusiveScissor,
+                                          uint32_t exclusiveScissorCount,
+                                          const VkBool32* pExclusiveScissorEnables);
     void vkCmdSetExclusiveScissorNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
                                     uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount,
@@ -2233,7 +2389,7 @@ class VkDecoderSnapshot {
                                               size_t snapshotTraceBytes,
                                               android::base::BumpPool* pool, VkResult input_result,
                                               VkPhysicalDevice physicalDevice, uint32_t* pToolCount,
-                                              VkPhysicalDeviceToolPropertiesEXT* pToolProperties);
+                                              VkPhysicalDeviceToolProperties* pToolProperties);
 #endif
 #ifdef VK_EXT_separate_stencil_usage
 #endif
@@ -2342,6 +2498,14 @@ class VkDecoderSnapshot {
 #endif
 #ifdef VK_EXT_shader_atomic_float2
 #endif
+#ifdef VK_EXT_surface_maintenance1
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+    void vkReleaseSwapchainImagesEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                     android::base::BumpPool* pool, VkResult input_result,
+                                     VkDevice device,
+                                     const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo);
+#endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -2397,25 +2561,26 @@ class VkDecoderSnapshot {
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+#endif
 #ifdef VK_EXT_private_data
     void vkCreatePrivateDataSlotEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                     android::base::BumpPool* pool, VkResult input_result,
-                                    VkDevice device,
-                                    const VkPrivateDataSlotCreateInfoEXT* pCreateInfo,
+                                    VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo,
                                     const VkAllocationCallbacks* pAllocator,
-                                    VkPrivateDataSlotEXT* pPrivateDataSlot);
+                                    VkPrivateDataSlot* pPrivateDataSlot);
     void vkDestroyPrivateDataSlotEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                      android::base::BumpPool* pool, VkDevice device,
-                                     VkPrivateDataSlotEXT privateDataSlot,
+                                     VkPrivateDataSlot privateDataSlot,
                                      const VkAllocationCallbacks* pAllocator);
     void vkSetPrivateDataEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkResult input_result, VkDevice device,
                              VkObjectType objectType, uint64_t objectHandle,
-                             VkPrivateDataSlotEXT privateDataSlot, uint64_t data);
+                             VkPrivateDataSlot privateDataSlot, uint64_t data);
     void vkGetPrivateDataEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                              android::base::BumpPool* pool, VkDevice device,
                              VkObjectType objectType, uint64_t objectHandle,
-                             VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData);
+                             VkPrivateDataSlot privateDataSlot, uint64_t* pData);
 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
 #endif
@@ -2423,6 +2588,69 @@ class VkDecoderSnapshot {
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+#endif
+#ifdef VK_EXT_metal_objects
+    void vkExportMetalObjectsEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkDevice device,
+                                 VkExportMetalObjectsInfoEXT* pMetalObjectsInfo);
+#endif
+#ifdef VK_EXT_descriptor_buffer
+    void vkGetDescriptorSetLayoutSizeEXT(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkDevice device, VkDescriptorSetLayout layout,
+                                         VkDeviceSize* pLayoutSizeInBytes);
+    void vkGetDescriptorSetLayoutBindingOffsetEXT(const uint8_t* snapshotTraceBegin,
+                                                  size_t snapshotTraceBytes,
+                                                  android::base::BumpPool* pool, VkDevice device,
+                                                  VkDescriptorSetLayout layout, uint32_t binding,
+                                                  VkDeviceSize* pOffset);
+    void vkGetDescriptorEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                            android::base::BumpPool* pool, VkDevice device,
+                            const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize,
+                            void* pDescriptor);
+    void vkCmdBindDescriptorBuffersEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                       uint32_t bufferCount,
+                                       const VkDescriptorBufferBindingInfoEXT* pBindingInfos);
+    void vkCmdSetDescriptorBufferOffsetsEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
+        VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount,
+        const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets);
+    void vkCmdBindDescriptorBufferEmbeddedSamplersEXT(const uint8_t* snapshotTraceBegin,
+                                                      size_t snapshotTraceBytes,
+                                                      android::base::BumpPool* pool,
+                                                      VkCommandBuffer commandBuffer,
+                                                      VkPipelineBindPoint pipelineBindPoint,
+                                                      VkPipelineLayout layout, uint32_t set);
+    void vkGetBufferOpaqueCaptureDescriptorDataEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo,
+        void* pData);
+    void vkGetImageOpaqueCaptureDescriptorDataEXT(const uint8_t* snapshotTraceBegin,
+                                                  size_t snapshotTraceBytes,
+                                                  android::base::BumpPool* pool,
+                                                  VkResult input_result, VkDevice device,
+                                                  const VkImageCaptureDescriptorDataInfoEXT* pInfo,
+                                                  void* pData);
+    void vkGetImageViewOpaqueCaptureDescriptorDataEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkDevice device,
+        const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData);
+    void vkGetSamplerOpaqueCaptureDescriptorDataEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo,
+        void* pData);
+    void vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkDevice device,
+        const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData);
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
     void vkCmdSetFragmentShadingRateEnumNV(const uint8_t* snapshotTraceBegin,
                                            size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -2440,8 +2668,25 @@ class VkDecoderSnapshot {
 #endif
 #ifdef VK_EXT_image_robustness
 #endif
+#ifdef VK_EXT_image_compression_control
+    void vkGetImageSubresourceLayout2EXT(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkDevice device, VkImage image,
+                                         const VkImageSubresource2EXT* pSubresource,
+                                         VkSubresourceLayout2EXT* pLayout);
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+#endif
 #ifdef VK_EXT_4444_formats
 #endif
+#ifdef VK_EXT_device_fault
+    void vkGetDeviceFaultInfoEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkResult input_result,
+                                 VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts,
+                                 VkDeviceFaultInfoEXT* pFaultInfo);
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 #endif
 #ifdef VK_NV_acquire_winrt_display
@@ -2477,6 +2722,10 @@ class VkDecoderSnapshot {
 #endif
 #ifdef VK_EXT_physical_device_drm
 #endif
+#ifdef VK_EXT_device_address_binding_report
+#endif
+#ifdef VK_EXT_depth_clip_control
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 #endif
 #ifdef VK_FUCHSIA_external_memory
@@ -2549,6 +2798,14 @@ class VkDecoderSnapshot {
         const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,
         VkRemoteAddressNV* pAddress);
 #endif
+#ifdef VK_EXT_pipeline_properties
+    void vkGetPipelinePropertiesEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                    android::base::BumpPool* pool, VkResult input_result,
+                                    VkDevice device, const VkPipelineInfoEXT* pPipelineInfo,
+                                    VkBaseOutStructure* pPipelineProperties);
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
     void vkCmdSetPatchControlPointsEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                                        android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
@@ -2585,6 +2842,8 @@ class VkDecoderSnapshot {
                                      android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
                                      uint32_t attachmentCount, const VkBool32* pColorWriteEnables);
 #endif
+#ifdef VK_EXT_primitives_generated_query
+#endif
 #ifdef VK_GOOGLE_gfxstream
     void vkMapMemoryIntoAddressSpaceGOOGLE(const uint8_t* snapshotTraceBegin,
                                            size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -2685,9 +2944,20 @@ class VkDecoderSnapshot {
     void vkGetBlobGOOGLE(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                          android::base::BumpPool* pool, VkResult input_result, VkDevice device,
                          VkDeviceMemory memory);
+    void vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkDevice device, VkDescriptorSet descriptorSet,
+        VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+        uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
+        const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
+        const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
+        const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
+        const uint8_t* pInlineUniformBlockData);
 #endif
 #ifdef VK_EXT_global_priority_query
 #endif
+#ifdef VK_EXT_image_view_min_lod
+#endif
 #ifdef VK_EXT_multi_draw
     void vkCmdDrawMultiEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
                            android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
@@ -2699,8 +2969,79 @@ class VkDecoderSnapshot {
                                   uint32_t instanceCount, uint32_t firstInstance, uint32_t stride,
                                   const int32_t* pVertexOffset);
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+#endif
+#ifdef VK_EXT_shader_tile_image
+#endif
+#ifdef VK_EXT_opacity_micromap
+    void vkCreateMicromapEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                             android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                             const VkMicromapCreateInfoEXT* pCreateInfo,
+                             const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap);
+    void vkDestroyMicromapEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                              android::base::BumpPool* pool, VkDevice device,
+                              VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator);
+    void vkCmdBuildMicromapsEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos);
+    void vkBuildMicromapsEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                             android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                             VkDeferredOperationKHR deferredOperation, uint32_t infoCount,
+                             const VkMicromapBuildInfoEXT* pInfos);
+    void vkCopyMicromapEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                           android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                           VkDeferredOperationKHR deferredOperation,
+                           const VkCopyMicromapInfoEXT* pInfo);
+    void vkCopyMicromapToMemoryEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkResult input_result,
+                                   VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                   const VkCopyMicromapToMemoryInfoEXT* pInfo);
+    void vkCopyMemoryToMicromapEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkResult input_result,
+                                   VkDevice device, VkDeferredOperationKHR deferredOperation,
+                                   const VkCopyMemoryToMicromapInfoEXT* pInfo);
+    void vkWriteMicromapsPropertiesEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkResult input_result,
+                                       VkDevice device, uint32_t micromapCount,
+                                       const VkMicromapEXT* pMicromaps, VkQueryType queryType,
+                                       size_t dataSize, void* pData, size_t stride);
+    void vkCmdCopyMicromapEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                              android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                              const VkCopyMicromapInfoEXT* pInfo);
+    void vkCmdCopyMicromapToMemoryEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                      android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                      const VkCopyMicromapToMemoryInfoEXT* pInfo);
+    void vkCmdCopyMemoryToMicromapEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                      android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                      const VkCopyMemoryToMicromapInfoEXT* pInfo);
+    void vkCmdWriteMicromapsPropertiesEXT(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer, uint32_t micromapCount,
+                                          const VkMicromapEXT* pMicromaps, VkQueryType queryType,
+                                          VkQueryPool queryPool, uint32_t firstQuery);
+    void vkGetDeviceMicromapCompatibilityEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo,
+        VkAccelerationStructureCompatibilityKHR* pCompatibility);
+    void vkGetMicromapBuildSizesEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                    android::base::BumpPool* pool, VkDevice device,
+                                    VkAccelerationStructureBuildTypeKHR buildType,
+                                    const VkMicromapBuildInfoEXT* pBuildInfo,
+                                    VkMicromapBuildSizesInfoEXT* pSizeInfo);
+#endif
+#ifdef VK_NV_displacement_micromap
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+    void vkCmdDrawClusterHUAWEI(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
+    void vkCmdDrawClusterIndirectHUAWEI(const uint8_t* snapshotTraceBegin,
+                                        size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                        VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                        VkDeviceSize offset);
+#endif
 #ifdef VK_EXT_border_color_swizzle
 #endif
 #ifdef VK_EXT_pageable_device_local_memory
@@ -2708,6 +3049,282 @@ class VkDecoderSnapshot {
                                       android::base::BumpPool* pool, VkDevice device,
                                       VkDeviceMemory memory, float priority);
 #endif
+#ifdef VK_ARM_shader_core_properties
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+    void vkGetDescriptorSetLayoutHostMappingInfoVALVE(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference,
+        VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping);
+    void vkGetDescriptorSetHostMappingVALVE(const uint8_t* snapshotTraceBegin,
+                                            size_t snapshotTraceBytes,
+                                            android::base::BumpPool* pool, VkDevice device,
+                                            VkDescriptorSet descriptorSet, void** ppData);
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+#endif
+#ifdef VK_NV_copy_memory_indirect
+    void vkCmdCopyMemoryIndirectNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   VkDeviceAddress copyBufferAddress, uint32_t copyCount,
+                                   uint32_t stride);
+    void vkCmdCopyMemoryToImageIndirectNV(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkDeviceAddress copyBufferAddress, uint32_t copyCount,
+                                          uint32_t stride, VkImage dstImage,
+                                          VkImageLayout dstImageLayout,
+                                          const VkImageSubresourceLayers* pImageSubresources);
+#endif
+#ifdef VK_NV_memory_decompression
+    void vkCmdDecompressMemoryNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                 android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                 uint32_t decompressRegionCount,
+                                 const VkDecompressMemoryRegionNV* pDecompressMemoryRegions);
+    void vkCmdDecompressMemoryIndirectCountNV(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress,
+        VkDeviceAddress indirectCommandsCountAddress, uint32_t stride);
+#endif
+#ifdef VK_NV_linear_color_attachment
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+#endif
+#ifdef VK_QCOM_image_processing
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+    void vkCmdSetTessellationDomainOriginEXT(const uint8_t* snapshotTraceBegin,
+                                             size_t snapshotTraceBytes,
+                                             android::base::BumpPool* pool,
+                                             VkCommandBuffer commandBuffer,
+                                             VkTessellationDomainOrigin domainOrigin);
+    void vkCmdSetDepthClampEnableEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                     VkBool32 depthClampEnable);
+    void vkCmdSetPolygonModeEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                VkPolygonMode polygonMode);
+    void vkCmdSetRasterizationSamplesEXT(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer,
+                                         VkSampleCountFlagBits rasterizationSamples);
+    void vkCmdSetSampleMaskEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                               android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                               VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask);
+    void vkCmdSetAlphaToCoverageEnableEXT(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkBool32 alphaToCoverageEnable);
+    void vkCmdSetAlphaToOneEnableEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                     VkBool32 alphaToOneEnable);
+    void vkCmdSetLogicOpEnableEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                  android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                  VkBool32 logicOpEnable);
+    void vkCmdSetColorBlendEnableEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                     android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                     uint32_t firstAttachment, uint32_t attachmentCount,
+                                     const VkBool32* pColorBlendEnables);
+    void vkCmdSetColorBlendEquationEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                       uint32_t firstAttachment, uint32_t attachmentCount,
+                                       const VkColorBlendEquationEXT* pColorBlendEquations);
+    void vkCmdSetColorWriteMaskEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   uint32_t firstAttachment, uint32_t attachmentCount,
+                                   const VkColorComponentFlags* pColorWriteMasks);
+    void vkCmdSetRasterizationStreamEXT(const uint8_t* snapshotTraceBegin,
+                                        size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                        VkCommandBuffer commandBuffer,
+                                        uint32_t rasterizationStream);
+    void vkCmdSetConservativeRasterizationModeEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkCommandBuffer commandBuffer,
+        VkConservativeRasterizationModeEXT conservativeRasterizationMode);
+    void vkCmdSetExtraPrimitiveOverestimationSizeEXT(const uint8_t* snapshotTraceBegin,
+                                                     size_t snapshotTraceBytes,
+                                                     android::base::BumpPool* pool,
+                                                     VkCommandBuffer commandBuffer,
+                                                     float extraPrimitiveOverestimationSize);
+    void vkCmdSetDepthClipEnableEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                    android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                    VkBool32 depthClipEnable);
+    void vkCmdSetSampleLocationsEnableEXT(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkBool32 sampleLocationsEnable);
+    void vkCmdSetColorBlendAdvancedEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                       uint32_t firstAttachment, uint32_t attachmentCount,
+                                       const VkColorBlendAdvancedEXT* pColorBlendAdvanced);
+    void vkCmdSetProvokingVertexModeEXT(const uint8_t* snapshotTraceBegin,
+                                        size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                        VkCommandBuffer commandBuffer,
+                                        VkProvokingVertexModeEXT provokingVertexMode);
+    void vkCmdSetLineRasterizationModeEXT(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkLineRasterizationModeEXT lineRasterizationMode);
+    void vkCmdSetLineStippleEnableEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                      android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                      VkBool32 stippledLineEnable);
+    void vkCmdSetDepthClipNegativeOneToOneEXT(const uint8_t* snapshotTraceBegin,
+                                              size_t snapshotTraceBytes,
+                                              android::base::BumpPool* pool,
+                                              VkCommandBuffer commandBuffer,
+                                              VkBool32 negativeOneToOne);
+    void vkCmdSetViewportWScalingEnableNV(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkBool32 viewportWScalingEnable);
+    void vkCmdSetViewportSwizzleNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   uint32_t firstViewport, uint32_t viewportCount,
+                                   const VkViewportSwizzleNV* pViewportSwizzles);
+    void vkCmdSetCoverageToColorEnableNV(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer,
+                                         VkBool32 coverageToColorEnable);
+    void vkCmdSetCoverageToColorLocationNV(const uint8_t* snapshotTraceBegin,
+                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                           VkCommandBuffer commandBuffer,
+                                           uint32_t coverageToColorLocation);
+    void vkCmdSetCoverageModulationModeNV(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkCoverageModulationModeNV coverageModulationMode);
+    void vkCmdSetCoverageModulationTableEnableNV(const uint8_t* snapshotTraceBegin,
+                                                 size_t snapshotTraceBytes,
+                                                 android::base::BumpPool* pool,
+                                                 VkCommandBuffer commandBuffer,
+                                                 VkBool32 coverageModulationTableEnable);
+    void vkCmdSetCoverageModulationTableNV(const uint8_t* snapshotTraceBegin,
+                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                           VkCommandBuffer commandBuffer,
+                                           uint32_t coverageModulationTableCount,
+                                           const float* pCoverageModulationTable);
+    void vkCmdSetShadingRateImageEnableNV(const uint8_t* snapshotTraceBegin,
+                                          size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                          VkCommandBuffer commandBuffer,
+                                          VkBool32 shadingRateImageEnable);
+    void vkCmdSetRepresentativeFragmentTestEnableNV(const uint8_t* snapshotTraceBegin,
+                                                    size_t snapshotTraceBytes,
+                                                    android::base::BumpPool* pool,
+                                                    VkCommandBuffer commandBuffer,
+                                                    VkBool32 representativeFragmentTestEnable);
+    void vkCmdSetCoverageReductionModeNV(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkCommandBuffer commandBuffer,
+                                         VkCoverageReductionModeNV coverageReductionMode);
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+#endif
+#ifdef VK_EXT_shader_module_identifier
+    void vkGetShaderModuleIdentifierEXT(const uint8_t* snapshotTraceBegin,
+                                        size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                        VkDevice device, VkShaderModule shaderModule,
+                                        VkShaderModuleIdentifierEXT* pIdentifier);
+    void vkGetShaderModuleCreateInfoIdentifierEXT(const uint8_t* snapshotTraceBegin,
+                                                  size_t snapshotTraceBytes,
+                                                  android::base::BumpPool* pool, VkDevice device,
+                                                  const VkShaderModuleCreateInfo* pCreateInfo,
+                                                  VkShaderModuleIdentifierEXT* pIdentifier);
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+    void vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkResult input_result, VkPhysicalDevice physicalDevice,
+        const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount,
+        VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties);
+    void vkCreateOpticalFlowSessionNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                      android::base::BumpPool* pool, VkResult input_result,
+                                      VkDevice device,
+                                      const VkOpticalFlowSessionCreateInfoNV* pCreateInfo,
+                                      const VkAllocationCallbacks* pAllocator,
+                                      VkOpticalFlowSessionNV* pSession);
+    void vkDestroyOpticalFlowSessionNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkDevice device,
+                                       VkOpticalFlowSessionNV session,
+                                       const VkAllocationCallbacks* pAllocator);
+    void vkBindOpticalFlowSessionImageNV(const uint8_t* snapshotTraceBegin,
+                                         size_t snapshotTraceBytes, android::base::BumpPool* pool,
+                                         VkResult input_result, VkDevice device,
+                                         VkOpticalFlowSessionNV session,
+                                         VkOpticalFlowSessionBindingPointNV bindingPoint,
+                                         VkImageView view, VkImageLayout layout);
+    void vkCmdOpticalFlowExecuteNV(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                   android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                   VkOpticalFlowSessionNV session,
+                                   const VkOpticalFlowExecuteInfoNV* pExecuteInfo);
+#endif
+#ifdef VK_EXT_legacy_dithering
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+#endif
+#ifdef VK_EXT_shader_object
+    void vkCreateShadersEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                            android::base::BumpPool* pool, VkResult input_result, VkDevice device,
+                            uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos,
+                            const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders);
+    void vkDestroyShaderEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                            android::base::BumpPool* pool, VkDevice device, VkShaderEXT shader,
+                            const VkAllocationCallbacks* pAllocator);
+    void vkGetShaderBinaryDataEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                  android::base::BumpPool* pool, VkResult input_result,
+                                  VkDevice device, VkShaderEXT shader, size_t* pDataSize,
+                                  void* pData);
+    void vkCmdBindShadersEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                             android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                             uint32_t stageCount, const VkShaderStageFlagBits* pStages,
+                             const VkShaderEXT* pShaders);
+#endif
+#ifdef VK_QCOM_tile_properties
+    void vkGetFramebufferTilePropertiesQCOM(const uint8_t* snapshotTraceBegin,
+                                            size_t snapshotTraceBytes,
+                                            android::base::BumpPool* pool, VkResult input_result,
+                                            VkDevice device, VkFramebuffer framebuffer,
+                                            uint32_t* pPropertiesCount,
+                                            VkTilePropertiesQCOM* pProperties);
+    void vkGetDynamicRenderingTilePropertiesQCOM(const uint8_t* snapshotTraceBegin,
+                                                 size_t snapshotTraceBytes,
+                                                 android::base::BumpPool* pool,
+                                                 VkResult input_result, VkDevice device,
+                                                 const VkRenderingInfo* pRenderingInfo,
+                                                 VkTilePropertiesQCOM* pProperties);
+#endif
+#ifdef VK_SEC_amigo_profiling
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+    void vkCmdSetAttachmentFeedbackLoopEnableEXT(const uint8_t* snapshotTraceBegin,
+                                                 size_t snapshotTraceBytes,
+                                                 android::base::BumpPool* pool,
+                                                 VkCommandBuffer commandBuffer,
+                                                 VkImageAspectFlags aspectMask);
+#endif
 #ifdef VK_KHR_acceleration_structure
     void vkCreateAccelerationStructureKHR(const uint8_t* snapshotTraceBegin,
                                           size_t snapshotTraceBytes, android::base::BumpPool* pool,
@@ -2825,6 +3442,19 @@ class VkDecoderSnapshot {
 #endif
 #ifdef VK_KHR_ray_query
 #endif
+#ifdef VK_EXT_mesh_shader
+    void vkCmdDrawMeshTasksEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                               android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                               uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
+    void vkCmdDrawMeshTasksIndirectEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+                                       android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+                                       VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount,
+                                       uint32_t stride);
+    void vkCmdDrawMeshTasksIndirectCountEXT(
+        const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+        VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer,
+        VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);
+#endif
 
    private:
     class Impl;
diff --git a/stream-servers/vulkan/VkSubDecoder.cpp b/stream-servers/vulkan/VkSubDecoder.cpp
index 4c9b3119..6f5f7002 100644
--- a/stream-servers/vulkan/VkSubDecoder.cpp
+++ b/stream-servers/vulkan/VkSubDecoder.cpp
@@ -15,8 +15,8 @@
 
 // Autogenerated module VkSubDecoder
 //
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (impl) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -1534,6 +1534,506 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
                 break;
             }
 #endif
+#ifdef VK_VERSION_1_3
+            case OP_vkCmdSetEvent2: {
+                android::base::beginTrace("vkCmdSetEvent2 subdecode");
+                VkEvent event;
+                const VkDependencyInfo* pDependencyInfo;
+                VkDependencyInfo stack_pDependencyInfo[1];
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
+                pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
+                reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkDependencyInfo*)(pDependencyInfo),
+                                                   readStreamPtrPtr);
+                if (pDependencyInfo) {
+                    transform_tohost_VkDependencyInfo(globalstate,
+                                                      (VkDependencyInfo*)(pDependencyInfo));
+                }
+                vk->vkCmdSetEvent2((VkCommandBuffer)dispatchHandle, event, pDependencyInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdResetEvent2: {
+                android::base::beginTrace("vkCmdResetEvent2 subdecode");
+                VkEvent event;
+                VkPipelineStageFlags2 stageMask;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
+                memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlags2));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
+                vk->vkCmdResetEvent2((VkCommandBuffer)dispatchHandle, event, stageMask);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdWaitEvents2: {
+                android::base::beginTrace("vkCmdWaitEvents2 subdecode");
+                uint32_t eventCount;
+                const VkEvent* pEvents;
+                VkEvent stack_pEvents[MAX_STACK_ITEMS];
+                const VkDependencyInfo* pDependencyInfos;
+                VkDependencyInfo stack_pDependencyInfos[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((eventCount)) <= MAX_STACK_ITEMS) {
+                    pEvents = (VkEvent*)stack_pEvents;
+                } else {
+                    readStream->alloc((void**)&pEvents, ((eventCount)) * sizeof(const VkEvent));
+                }
+                if (((eventCount))) {
+                    uint8_t* cgen_var_0_ptr = (uint8_t*)(*readStreamPtrPtr);
+                    *readStreamPtrPtr += 8 * ((eventCount));
+                    for (uint32_t k = 0; k < ((eventCount)); ++k) {
+                        uint64_t tmpval;
+                        memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
+                        *(((VkEvent*)pEvents) + k) = (VkEvent)unbox_VkEvent((VkEvent)tmpval);
+                    }
+                }
+                if (((eventCount)) <= MAX_STACK_ITEMS) {
+                    pDependencyInfos = (VkDependencyInfo*)stack_pDependencyInfos;
+                } else {
+                    readStream->alloc((void**)&pDependencyInfos,
+                                      ((eventCount)) * sizeof(const VkDependencyInfo));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
+                    reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                       (VkDependencyInfo*)(pDependencyInfos + i),
+                                                       readStreamPtrPtr);
+                }
+                if (pDependencyInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
+                        transform_tohost_VkDependencyInfo(
+                            globalstate, (VkDependencyInfo*)(pDependencyInfos + i));
+                    }
+                }
+                vk->vkCmdWaitEvents2((VkCommandBuffer)dispatchHandle, eventCount, pEvents,
+                                     pDependencyInfos);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdPipelineBarrier2: {
+                android::base::beginTrace("vkCmdPipelineBarrier2 subdecode");
+                const VkDependencyInfo* pDependencyInfo;
+                VkDependencyInfo stack_pDependencyInfo[1];
+                pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
+                reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkDependencyInfo*)(pDependencyInfo),
+                                                   readStreamPtrPtr);
+                if (pDependencyInfo) {
+                    transform_tohost_VkDependencyInfo(globalstate,
+                                                      (VkDependencyInfo*)(pDependencyInfo));
+                }
+                vk->vkCmdPipelineBarrier2((VkCommandBuffer)dispatchHandle, pDependencyInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdWriteTimestamp2: {
+                android::base::beginTrace("vkCmdWriteTimestamp2 subdecode");
+                VkPipelineStageFlags2 stage;
+                VkQueryPool queryPool;
+                uint32_t query;
+                memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlags2));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkQueryPool*)&queryPool =
+                    (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
+                memcpy((uint32_t*)&query, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdWriteTimestamp2((VkCommandBuffer)dispatchHandle, stage, queryPool, query);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyBuffer2: {
+                android::base::beginTrace("vkCmdCopyBuffer2 subdecode");
+                const VkCopyBufferInfo2* pCopyBufferInfo;
+                VkCopyBufferInfo2 stack_pCopyBufferInfo[1];
+                pCopyBufferInfo = (VkCopyBufferInfo2*)stack_pCopyBufferInfo;
+                reservedunmarshal_VkCopyBufferInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                    (VkCopyBufferInfo2*)(pCopyBufferInfo),
+                                                    readStreamPtrPtr);
+                if (pCopyBufferInfo) {
+                    transform_tohost_VkCopyBufferInfo2(globalstate,
+                                                       (VkCopyBufferInfo2*)(pCopyBufferInfo));
+                }
+                vk->vkCmdCopyBuffer2((VkCommandBuffer)dispatchHandle, pCopyBufferInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyImage2: {
+                android::base::beginTrace("vkCmdCopyImage2 subdecode");
+                const VkCopyImageInfo2* pCopyImageInfo;
+                VkCopyImageInfo2 stack_pCopyImageInfo[1];
+                pCopyImageInfo = (VkCopyImageInfo2*)stack_pCopyImageInfo;
+                reservedunmarshal_VkCopyImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkCopyImageInfo2*)(pCopyImageInfo),
+                                                   readStreamPtrPtr);
+                if (pCopyImageInfo) {
+                    transform_tohost_VkCopyImageInfo2(globalstate,
+                                                      (VkCopyImageInfo2*)(pCopyImageInfo));
+                }
+                vk->vkCmdCopyImage2((VkCommandBuffer)dispatchHandle, pCopyImageInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyBufferToImage2: {
+                android::base::beginTrace("vkCmdCopyBufferToImage2 subdecode");
+                const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
+                VkCopyBufferToImageInfo2 stack_pCopyBufferToImageInfo[1];
+                pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2*)stack_pCopyBufferToImageInfo;
+                reservedunmarshal_VkCopyBufferToImageInfo2(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
+                if (pCopyBufferToImageInfo) {
+                    transform_tohost_VkCopyBufferToImageInfo2(
+                        globalstate, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
+                }
+                vk->vkCmdCopyBufferToImage2((VkCommandBuffer)dispatchHandle,
+                                            pCopyBufferToImageInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyImageToBuffer2: {
+                android::base::beginTrace("vkCmdCopyImageToBuffer2 subdecode");
+                const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
+                VkCopyImageToBufferInfo2 stack_pCopyImageToBufferInfo[1];
+                pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2*)stack_pCopyImageToBufferInfo;
+                reservedunmarshal_VkCopyImageToBufferInfo2(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
+                if (pCopyImageToBufferInfo) {
+                    transform_tohost_VkCopyImageToBufferInfo2(
+                        globalstate, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
+                }
+                vk->vkCmdCopyImageToBuffer2((VkCommandBuffer)dispatchHandle,
+                                            pCopyImageToBufferInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBlitImage2: {
+                android::base::beginTrace("vkCmdBlitImage2 subdecode");
+                const VkBlitImageInfo2* pBlitImageInfo;
+                VkBlitImageInfo2 stack_pBlitImageInfo[1];
+                pBlitImageInfo = (VkBlitImageInfo2*)stack_pBlitImageInfo;
+                reservedunmarshal_VkBlitImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkBlitImageInfo2*)(pBlitImageInfo),
+                                                   readStreamPtrPtr);
+                if (pBlitImageInfo) {
+                    transform_tohost_VkBlitImageInfo2(globalstate,
+                                                      (VkBlitImageInfo2*)(pBlitImageInfo));
+                }
+                vk->vkCmdBlitImage2((VkCommandBuffer)dispatchHandle, pBlitImageInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdResolveImage2: {
+                android::base::beginTrace("vkCmdResolveImage2 subdecode");
+                const VkResolveImageInfo2* pResolveImageInfo;
+                VkResolveImageInfo2 stack_pResolveImageInfo[1];
+                pResolveImageInfo = (VkResolveImageInfo2*)stack_pResolveImageInfo;
+                reservedunmarshal_VkResolveImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                      (VkResolveImageInfo2*)(pResolveImageInfo),
+                                                      readStreamPtrPtr);
+                if (pResolveImageInfo) {
+                    transform_tohost_VkResolveImageInfo2(globalstate,
+                                                         (VkResolveImageInfo2*)(pResolveImageInfo));
+                }
+                vk->vkCmdResolveImage2((VkCommandBuffer)dispatchHandle, pResolveImageInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBeginRendering: {
+                android::base::beginTrace("vkCmdBeginRendering subdecode");
+                const VkRenderingInfo* pRenderingInfo;
+                VkRenderingInfo stack_pRenderingInfo[1];
+                pRenderingInfo = (VkRenderingInfo*)stack_pRenderingInfo;
+                reservedunmarshal_VkRenderingInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                  (VkRenderingInfo*)(pRenderingInfo),
+                                                  readStreamPtrPtr);
+                if (pRenderingInfo) {
+                    transform_tohost_VkRenderingInfo(globalstate,
+                                                     (VkRenderingInfo*)(pRenderingInfo));
+                }
+                vk->vkCmdBeginRendering((VkCommandBuffer)dispatchHandle, pRenderingInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdEndRendering: {
+                android::base::beginTrace("vkCmdEndRendering subdecode");
+                vk->vkCmdEndRendering((VkCommandBuffer)dispatchHandle);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCullMode: {
+                android::base::beginTrace("vkCmdSetCullMode subdecode");
+                VkCullModeFlags cullMode;
+                memcpy((VkCullModeFlags*)&cullMode, *readStreamPtrPtr, sizeof(VkCullModeFlags));
+                *readStreamPtrPtr += sizeof(VkCullModeFlags);
+                vk->vkCmdSetCullMode((VkCommandBuffer)dispatchHandle, cullMode);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetFrontFace: {
+                android::base::beginTrace("vkCmdSetFrontFace subdecode");
+                VkFrontFace frontFace;
+                memcpy((VkFrontFace*)&frontFace, *readStreamPtrPtr, sizeof(VkFrontFace));
+                *readStreamPtrPtr += sizeof(VkFrontFace);
+                vk->vkCmdSetFrontFace((VkCommandBuffer)dispatchHandle, frontFace);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetPrimitiveTopology: {
+                android::base::beginTrace("vkCmdSetPrimitiveTopology subdecode");
+                VkPrimitiveTopology primitiveTopology;
+                memcpy((VkPrimitiveTopology*)&primitiveTopology, *readStreamPtrPtr,
+                       sizeof(VkPrimitiveTopology));
+                *readStreamPtrPtr += sizeof(VkPrimitiveTopology);
+                vk->vkCmdSetPrimitiveTopology((VkCommandBuffer)dispatchHandle, primitiveTopology);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetViewportWithCount: {
+                android::base::beginTrace("vkCmdSetViewportWithCount subdecode");
+                uint32_t viewportCount;
+                const VkViewport* pViewports;
+                VkViewport stack_pViewports[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((viewportCount)) <= MAX_STACK_ITEMS) {
+                    pViewports = (VkViewport*)stack_pViewports;
+                } else {
+                    readStream->alloc((void**)&pViewports,
+                                      ((viewportCount)) * sizeof(const VkViewport));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                    reservedunmarshal_VkViewport(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                 (VkViewport*)(pViewports + i), readStreamPtrPtr);
+                }
+                if (pViewports) {
+                    for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                        transform_tohost_VkViewport(globalstate, (VkViewport*)(pViewports + i));
+                    }
+                }
+                vk->vkCmdSetViewportWithCount((VkCommandBuffer)dispatchHandle, viewportCount,
+                                              pViewports);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetScissorWithCount: {
+                android::base::beginTrace("vkCmdSetScissorWithCount subdecode");
+                uint32_t scissorCount;
+                const VkRect2D* pScissors;
+                VkRect2D stack_pScissors[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&scissorCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((scissorCount)) <= MAX_STACK_ITEMS) {
+                    pScissors = (VkRect2D*)stack_pScissors;
+                } else {
+                    readStream->alloc((void**)&pScissors,
+                                      ((scissorCount)) * sizeof(const VkRect2D));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+                    reservedunmarshal_VkRect2D(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                               (VkRect2D*)(pScissors + i), readStreamPtrPtr);
+                }
+                if (pScissors) {
+                    for (uint32_t i = 0; i < (uint32_t)((scissorCount)); ++i) {
+                        transform_tohost_VkRect2D(globalstate, (VkRect2D*)(pScissors + i));
+                    }
+                }
+                vk->vkCmdSetScissorWithCount((VkCommandBuffer)dispatchHandle, scissorCount,
+                                             pScissors);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBindVertexBuffers2: {
+                android::base::beginTrace("vkCmdBindVertexBuffers2 subdecode");
+                uint32_t firstBinding;
+                uint32_t bindingCount;
+                const VkBuffer* pBuffers;
+                VkBuffer stack_pBuffers[MAX_STACK_ITEMS];
+                const VkDeviceSize* pOffsets;
+                VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
+                const VkDeviceSize* pSizes;
+                VkDeviceSize stack_pSizes[MAX_STACK_ITEMS];
+                const VkDeviceSize* pStrides;
+                VkDeviceSize stack_pStrides[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstBinding, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&bindingCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                // WARNING PTR CHECK
+                memcpy((VkBuffer**)&pBuffers, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pBuffers);
+                *readStreamPtrPtr += 8;
+                if (pBuffers) {
+                    if (((bindingCount)) <= MAX_STACK_ITEMS) {
+                        pBuffers = (VkBuffer*)stack_pBuffers;
+                    } else {
+                        readStream->alloc((void**)&pBuffers,
+                                          ((bindingCount)) * sizeof(const VkBuffer));
+                    }
+                    if (((bindingCount))) {
+                        uint8_t* cgen_var_0_0_ptr = (uint8_t*)(*readStreamPtrPtr);
+                        *readStreamPtrPtr += 8 * ((bindingCount));
+                        for (uint32_t k = 0; k < ((bindingCount)); ++k) {
+                            uint64_t tmpval;
+                            memcpy(&tmpval, cgen_var_0_0_ptr + k * 8, sizeof(uint64_t));
+                            *(((VkBuffer*)pBuffers) + k) =
+                                (VkBuffer)unbox_VkBuffer((VkBuffer)tmpval);
+                        }
+                    }
+                }
+                if (((bindingCount)) <= MAX_STACK_ITEMS) {
+                    pOffsets = (VkDeviceSize*)stack_pOffsets;
+                } else {
+                    readStream->alloc((void**)&pOffsets,
+                                      ((bindingCount)) * sizeof(const VkDeviceSize));
+                }
+                memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
+                       ((bindingCount)) * sizeof(const VkDeviceSize));
+                *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
+                // WARNING PTR CHECK
+                memcpy((VkDeviceSize**)&pSizes, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pSizes);
+                *readStreamPtrPtr += 8;
+                if (pSizes) {
+                    if (((bindingCount)) <= MAX_STACK_ITEMS) {
+                        pSizes = (VkDeviceSize*)stack_pSizes;
+                    } else {
+                        readStream->alloc((void**)&pSizes,
+                                          ((bindingCount)) * sizeof(const VkDeviceSize));
+                    }
+                    memcpy((VkDeviceSize*)pSizes, *readStreamPtrPtr,
+                           ((bindingCount)) * sizeof(const VkDeviceSize));
+                    *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
+                }
+                // WARNING PTR CHECK
+                memcpy((VkDeviceSize**)&pStrides, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pStrides);
+                *readStreamPtrPtr += 8;
+                if (pStrides) {
+                    if (((bindingCount)) <= MAX_STACK_ITEMS) {
+                        pStrides = (VkDeviceSize*)stack_pStrides;
+                    } else {
+                        readStream->alloc((void**)&pStrides,
+                                          ((bindingCount)) * sizeof(const VkDeviceSize));
+                    }
+                    memcpy((VkDeviceSize*)pStrides, *readStreamPtrPtr,
+                           ((bindingCount)) * sizeof(const VkDeviceSize));
+                    *readStreamPtrPtr += ((bindingCount)) * sizeof(const VkDeviceSize);
+                }
+                vk->vkCmdBindVertexBuffers2((VkCommandBuffer)dispatchHandle, firstBinding,
+                                            bindingCount, pBuffers, pOffsets, pSizes, pStrides);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthTestEnable: {
+                android::base::beginTrace("vkCmdSetDepthTestEnable subdecode");
+                VkBool32 depthTestEnable;
+                memcpy((VkBool32*)&depthTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthTestEnable((VkCommandBuffer)dispatchHandle, depthTestEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthWriteEnable: {
+                android::base::beginTrace("vkCmdSetDepthWriteEnable subdecode");
+                VkBool32 depthWriteEnable;
+                memcpy((VkBool32*)&depthWriteEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthWriteEnable((VkCommandBuffer)dispatchHandle, depthWriteEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthCompareOp: {
+                android::base::beginTrace("vkCmdSetDepthCompareOp subdecode");
+                VkCompareOp depthCompareOp;
+                memcpy((VkCompareOp*)&depthCompareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
+                *readStreamPtrPtr += sizeof(VkCompareOp);
+                vk->vkCmdSetDepthCompareOp((VkCommandBuffer)dispatchHandle, depthCompareOp);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthBoundsTestEnable: {
+                android::base::beginTrace("vkCmdSetDepthBoundsTestEnable subdecode");
+                VkBool32 depthBoundsTestEnable;
+                memcpy((VkBool32*)&depthBoundsTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthBoundsTestEnable((VkCommandBuffer)dispatchHandle,
+                                                  depthBoundsTestEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetStencilTestEnable: {
+                android::base::beginTrace("vkCmdSetStencilTestEnable subdecode");
+                VkBool32 stencilTestEnable;
+                memcpy((VkBool32*)&stencilTestEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetStencilTestEnable((VkCommandBuffer)dispatchHandle, stencilTestEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetStencilOp: {
+                android::base::beginTrace("vkCmdSetStencilOp subdecode");
+                VkStencilFaceFlags faceMask;
+                VkStencilOp failOp;
+                VkStencilOp passOp;
+                VkStencilOp depthFailOp;
+                VkCompareOp compareOp;
+                memcpy((VkStencilFaceFlags*)&faceMask, *readStreamPtrPtr,
+                       sizeof(VkStencilFaceFlags));
+                *readStreamPtrPtr += sizeof(VkStencilFaceFlags);
+                memcpy((VkStencilOp*)&failOp, *readStreamPtrPtr, sizeof(VkStencilOp));
+                *readStreamPtrPtr += sizeof(VkStencilOp);
+                memcpy((VkStencilOp*)&passOp, *readStreamPtrPtr, sizeof(VkStencilOp));
+                *readStreamPtrPtr += sizeof(VkStencilOp);
+                memcpy((VkStencilOp*)&depthFailOp, *readStreamPtrPtr, sizeof(VkStencilOp));
+                *readStreamPtrPtr += sizeof(VkStencilOp);
+                memcpy((VkCompareOp*)&compareOp, *readStreamPtrPtr, sizeof(VkCompareOp));
+                *readStreamPtrPtr += sizeof(VkCompareOp);
+                vk->vkCmdSetStencilOp((VkCommandBuffer)dispatchHandle, faceMask, failOp, passOp,
+                                      depthFailOp, compareOp);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetRasterizerDiscardEnable: {
+                android::base::beginTrace("vkCmdSetRasterizerDiscardEnable subdecode");
+                VkBool32 rasterizerDiscardEnable;
+                memcpy((VkBool32*)&rasterizerDiscardEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetRasterizerDiscardEnable((VkCommandBuffer)dispatchHandle,
+                                                    rasterizerDiscardEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthBiasEnable: {
+                android::base::beginTrace("vkCmdSetDepthBiasEnable subdecode");
+                VkBool32 depthBiasEnable;
+                memcpy((VkBool32*)&depthBiasEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthBiasEnable((VkCommandBuffer)dispatchHandle, depthBiasEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetPrimitiveRestartEnable: {
+                android::base::beginTrace("vkCmdSetPrimitiveRestartEnable subdecode");
+                VkBool32 primitiveRestartEnable;
+                memcpy((VkBool32*)&primitiveRestartEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetPrimitiveRestartEnable((VkCommandBuffer)dispatchHandle,
+                                                   primitiveRestartEnable);
+                android::base::endTrace();
+                break;
+            }
+#endif
 #ifdef VK_KHR_surface
 #endif
 #ifdef VK_KHR_swapchain
@@ -1607,33 +2107,35 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #ifdef VK_KHR_video_decode_queue
             case OP_vkCmdDecodeVideoKHR: {
                 android::base::beginTrace("vkCmdDecodeVideoKHR subdecode");
-                const VkVideoDecodeInfoKHR* pFrameInfo;
-                VkVideoDecodeInfoKHR stack_pFrameInfo[1];
-                pFrameInfo = (VkVideoDecodeInfoKHR*)stack_pFrameInfo;
+                const VkVideoDecodeInfoKHR* pDecodeInfo;
+                VkVideoDecodeInfoKHR stack_pDecodeInfo[1];
+                pDecodeInfo = (VkVideoDecodeInfoKHR*)stack_pDecodeInfo;
                 reservedunmarshal_VkVideoDecodeInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                       (VkVideoDecodeInfoKHR*)(pFrameInfo),
+                                                       (VkVideoDecodeInfoKHR*)(pDecodeInfo),
                                                        readStreamPtrPtr);
-                if (pFrameInfo) {
+                if (pDecodeInfo) {
                     transform_tohost_VkVideoDecodeInfoKHR(globalstate,
-                                                          (VkVideoDecodeInfoKHR*)(pFrameInfo));
+                                                          (VkVideoDecodeInfoKHR*)(pDecodeInfo));
                 }
-                vk->vkCmdDecodeVideoKHR((VkCommandBuffer)dispatchHandle, pFrameInfo);
+                vk->vkCmdDecodeVideoKHR((VkCommandBuffer)dispatchHandle, pDecodeInfo);
                 android::base::endTrace();
                 break;
             }
 #endif
+#ifdef VK_KHR_video_decode_h264
+#endif
 #ifdef VK_KHR_dynamic_rendering
             case OP_vkCmdBeginRenderingKHR: {
                 android::base::beginTrace("vkCmdBeginRenderingKHR subdecode");
-                const VkRenderingInfoKHR* pRenderingInfo;
-                VkRenderingInfoKHR stack_pRenderingInfo[1];
-                pRenderingInfo = (VkRenderingInfoKHR*)stack_pRenderingInfo;
-                reservedunmarshal_VkRenderingInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                     (VkRenderingInfoKHR*)(pRenderingInfo),
-                                                     readStreamPtrPtr);
+                const VkRenderingInfo* pRenderingInfo;
+                VkRenderingInfo stack_pRenderingInfo[1];
+                pRenderingInfo = (VkRenderingInfo*)stack_pRenderingInfo;
+                reservedunmarshal_VkRenderingInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                  (VkRenderingInfo*)(pRenderingInfo),
+                                                  readStreamPtrPtr);
                 if (pRenderingInfo) {
-                    transform_tohost_VkRenderingInfoKHR(globalstate,
-                                                        (VkRenderingInfoKHR*)(pRenderingInfo));
+                    transform_tohost_VkRenderingInfo(globalstate,
+                                                     (VkRenderingInfo*)(pRenderingInfo));
                 }
                 vk->vkCmdBeginRenderingKHR((VkCommandBuffer)dispatchHandle, pRenderingInfo);
                 android::base::endTrace();
@@ -1978,6 +2480,10 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_KHR_shader_clock
 #endif
+#ifdef VK_KHR_video_decode_h265
+#endif
+#ifdef VK_KHR_global_priority
+#endif
 #ifdef VK_KHR_driver_properties
 #endif
 #ifdef VK_KHR_shader_float_controls
@@ -2029,6 +2535,8 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_KHR_pipeline_executable_properties
 #endif
+#ifdef VK_KHR_map_memory2
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -2059,19 +2567,19 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
             case OP_vkCmdSetEvent2KHR: {
                 android::base::beginTrace("vkCmdSetEvent2KHR subdecode");
                 VkEvent event;
-                const VkDependencyInfoKHR* pDependencyInfo;
-                VkDependencyInfoKHR stack_pDependencyInfo[1];
+                const VkDependencyInfo* pDependencyInfo;
+                VkDependencyInfo stack_pDependencyInfo[1];
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
                 *readStreamPtrPtr += 1 * 8;
                 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
-                pDependencyInfo = (VkDependencyInfoKHR*)stack_pDependencyInfo;
-                reservedunmarshal_VkDependencyInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                      (VkDependencyInfoKHR*)(pDependencyInfo),
-                                                      readStreamPtrPtr);
+                pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
+                reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkDependencyInfo*)(pDependencyInfo),
+                                                   readStreamPtrPtr);
                 if (pDependencyInfo) {
-                    transform_tohost_VkDependencyInfoKHR(globalstate,
-                                                         (VkDependencyInfoKHR*)(pDependencyInfo));
+                    transform_tohost_VkDependencyInfo(globalstate,
+                                                      (VkDependencyInfo*)(pDependencyInfo));
                 }
                 vk->vkCmdSetEvent2KHR((VkCommandBuffer)dispatchHandle, event, pDependencyInfo);
                 android::base::endTrace();
@@ -2080,14 +2588,14 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
             case OP_vkCmdResetEvent2KHR: {
                 android::base::beginTrace("vkCmdResetEvent2KHR subdecode");
                 VkEvent event;
-                VkPipelineStageFlags2KHR stageMask;
+                VkPipelineStageFlags2 stageMask;
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
                 *readStreamPtrPtr += 1 * 8;
                 *(VkEvent*)&event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_0));
-                memcpy((VkPipelineStageFlags2KHR*)&stageMask, *readStreamPtrPtr,
-                       sizeof(VkPipelineStageFlags2KHR));
-                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2KHR);
+                memcpy((VkPipelineStageFlags2*)&stageMask, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlags2));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
                 vk->vkCmdResetEvent2KHR((VkCommandBuffer)dispatchHandle, event, stageMask);
                 android::base::endTrace();
                 break;
@@ -2097,8 +2605,8 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
                 uint32_t eventCount;
                 const VkEvent* pEvents;
                 VkEvent stack_pEvents[MAX_STACK_ITEMS];
-                const VkDependencyInfoKHR* pDependencyInfos;
-                VkDependencyInfoKHR stack_pDependencyInfos[MAX_STACK_ITEMS];
+                const VkDependencyInfo* pDependencyInfos;
+                VkDependencyInfo stack_pDependencyInfos[MAX_STACK_ITEMS];
                 memcpy((uint32_t*)&eventCount, *readStreamPtrPtr, sizeof(uint32_t));
                 *readStreamPtrPtr += sizeof(uint32_t);
                 if (((eventCount)) <= MAX_STACK_ITEMS) {
@@ -2116,20 +2624,20 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
                     }
                 }
                 if (((eventCount)) <= MAX_STACK_ITEMS) {
-                    pDependencyInfos = (VkDependencyInfoKHR*)stack_pDependencyInfos;
+                    pDependencyInfos = (VkDependencyInfo*)stack_pDependencyInfos;
                 } else {
                     readStream->alloc((void**)&pDependencyInfos,
-                                      ((eventCount)) * sizeof(const VkDependencyInfoKHR));
+                                      ((eventCount)) * sizeof(const VkDependencyInfo));
                 }
                 for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
-                    reservedunmarshal_VkDependencyInfoKHR(
-                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                        (VkDependencyInfoKHR*)(pDependencyInfos + i), readStreamPtrPtr);
+                    reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                       (VkDependencyInfo*)(pDependencyInfos + i),
+                                                       readStreamPtrPtr);
                 }
                 if (pDependencyInfos) {
                     for (uint32_t i = 0; i < (uint32_t)((eventCount)); ++i) {
-                        transform_tohost_VkDependencyInfoKHR(
-                            globalstate, (VkDependencyInfoKHR*)(pDependencyInfos + i));
+                        transform_tohost_VkDependencyInfo(
+                            globalstate, (VkDependencyInfo*)(pDependencyInfos + i));
                     }
                 }
                 vk->vkCmdWaitEvents2KHR((VkCommandBuffer)dispatchHandle, eventCount, pEvents,
@@ -2139,15 +2647,15 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
             }
             case OP_vkCmdPipelineBarrier2KHR: {
                 android::base::beginTrace("vkCmdPipelineBarrier2KHR subdecode");
-                const VkDependencyInfoKHR* pDependencyInfo;
-                VkDependencyInfoKHR stack_pDependencyInfo[1];
-                pDependencyInfo = (VkDependencyInfoKHR*)stack_pDependencyInfo;
-                reservedunmarshal_VkDependencyInfoKHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                      (VkDependencyInfoKHR*)(pDependencyInfo),
-                                                      readStreamPtrPtr);
+                const VkDependencyInfo* pDependencyInfo;
+                VkDependencyInfo stack_pDependencyInfo[1];
+                pDependencyInfo = (VkDependencyInfo*)stack_pDependencyInfo;
+                reservedunmarshal_VkDependencyInfo(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkDependencyInfo*)(pDependencyInfo),
+                                                   readStreamPtrPtr);
                 if (pDependencyInfo) {
-                    transform_tohost_VkDependencyInfoKHR(globalstate,
-                                                         (VkDependencyInfoKHR*)(pDependencyInfo));
+                    transform_tohost_VkDependencyInfo(globalstate,
+                                                      (VkDependencyInfo*)(pDependencyInfo));
                 }
                 vk->vkCmdPipelineBarrier2KHR((VkCommandBuffer)dispatchHandle, pDependencyInfo);
                 android::base::endTrace();
@@ -2155,12 +2663,12 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
             }
             case OP_vkCmdWriteTimestamp2KHR: {
                 android::base::beginTrace("vkCmdWriteTimestamp2KHR subdecode");
-                VkPipelineStageFlags2KHR stage;
+                VkPipelineStageFlags2 stage;
                 VkQueryPool queryPool;
                 uint32_t query;
-                memcpy((VkPipelineStageFlags2KHR*)&stage, *readStreamPtrPtr,
-                       sizeof(VkPipelineStageFlags2KHR));
-                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2KHR);
+                memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlags2));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
                 *readStreamPtrPtr += 1 * 8;
@@ -2175,13 +2683,13 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
             }
             case OP_vkCmdWriteBufferMarker2AMD: {
                 android::base::beginTrace("vkCmdWriteBufferMarker2AMD subdecode");
-                VkPipelineStageFlags2KHR stage;
+                VkPipelineStageFlags2 stage;
                 VkBuffer dstBuffer;
                 VkDeviceSize dstOffset;
                 uint32_t marker;
-                memcpy((VkPipelineStageFlags2KHR*)&stage, *readStreamPtrPtr,
-                       sizeof(VkPipelineStageFlags2KHR));
-                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2KHR);
+                memcpy((VkPipelineStageFlags2*)&stage, *readStreamPtrPtr,
+                       sizeof(VkPipelineStageFlags2));
+                *readStreamPtrPtr += sizeof(VkPipelineStageFlags2);
                 uint64_t cgen_var_0;
                 memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
                 *readStreamPtrPtr += 1 * 8;
@@ -2196,6 +2704,8 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
                 break;
             }
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
@@ -2205,15 +2715,15 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #ifdef VK_KHR_copy_commands2
             case OP_vkCmdCopyBuffer2KHR: {
                 android::base::beginTrace("vkCmdCopyBuffer2KHR subdecode");
-                const VkCopyBufferInfo2KHR* pCopyBufferInfo;
-                VkCopyBufferInfo2KHR stack_pCopyBufferInfo[1];
-                pCopyBufferInfo = (VkCopyBufferInfo2KHR*)stack_pCopyBufferInfo;
-                reservedunmarshal_VkCopyBufferInfo2KHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                       (VkCopyBufferInfo2KHR*)(pCopyBufferInfo),
-                                                       readStreamPtrPtr);
+                const VkCopyBufferInfo2* pCopyBufferInfo;
+                VkCopyBufferInfo2 stack_pCopyBufferInfo[1];
+                pCopyBufferInfo = (VkCopyBufferInfo2*)stack_pCopyBufferInfo;
+                reservedunmarshal_VkCopyBufferInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                    (VkCopyBufferInfo2*)(pCopyBufferInfo),
+                                                    readStreamPtrPtr);
                 if (pCopyBufferInfo) {
-                    transform_tohost_VkCopyBufferInfo2KHR(globalstate,
-                                                          (VkCopyBufferInfo2KHR*)(pCopyBufferInfo));
+                    transform_tohost_VkCopyBufferInfo2(globalstate,
+                                                       (VkCopyBufferInfo2*)(pCopyBufferInfo));
                 }
                 vk->vkCmdCopyBuffer2KHR((VkCommandBuffer)dispatchHandle, pCopyBufferInfo);
                 android::base::endTrace();
@@ -2221,15 +2731,15 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
             }
             case OP_vkCmdCopyImage2KHR: {
                 android::base::beginTrace("vkCmdCopyImage2KHR subdecode");
-                const VkCopyImageInfo2KHR* pCopyImageInfo;
-                VkCopyImageInfo2KHR stack_pCopyImageInfo[1];
-                pCopyImageInfo = (VkCopyImageInfo2KHR*)stack_pCopyImageInfo;
-                reservedunmarshal_VkCopyImageInfo2KHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                      (VkCopyImageInfo2KHR*)(pCopyImageInfo),
-                                                      readStreamPtrPtr);
+                const VkCopyImageInfo2* pCopyImageInfo;
+                VkCopyImageInfo2 stack_pCopyImageInfo[1];
+                pCopyImageInfo = (VkCopyImageInfo2*)stack_pCopyImageInfo;
+                reservedunmarshal_VkCopyImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkCopyImageInfo2*)(pCopyImageInfo),
+                                                   readStreamPtrPtr);
                 if (pCopyImageInfo) {
-                    transform_tohost_VkCopyImageInfo2KHR(globalstate,
-                                                         (VkCopyImageInfo2KHR*)(pCopyImageInfo));
+                    transform_tohost_VkCopyImageInfo2(globalstate,
+                                                      (VkCopyImageInfo2*)(pCopyImageInfo));
                 }
                 vk->vkCmdCopyImage2KHR((VkCommandBuffer)dispatchHandle, pCopyImageInfo);
                 android::base::endTrace();
@@ -2237,15 +2747,15 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
             }
             case OP_vkCmdCopyBufferToImage2KHR: {
                 android::base::beginTrace("vkCmdCopyBufferToImage2KHR subdecode");
-                const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo;
-                VkCopyBufferToImageInfo2KHR stack_pCopyBufferToImageInfo[1];
-                pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2KHR*)stack_pCopyBufferToImageInfo;
-                reservedunmarshal_VkCopyBufferToImageInfo2KHR(
+                const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
+                VkCopyBufferToImageInfo2 stack_pCopyBufferToImageInfo[1];
+                pCopyBufferToImageInfo = (VkCopyBufferToImageInfo2*)stack_pCopyBufferToImageInfo;
+                reservedunmarshal_VkCopyBufferToImageInfo2(
                     readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                    (VkCopyBufferToImageInfo2KHR*)(pCopyBufferToImageInfo), readStreamPtrPtr);
+                    (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo), readStreamPtrPtr);
                 if (pCopyBufferToImageInfo) {
-                    transform_tohost_VkCopyBufferToImageInfo2KHR(
-                        globalstate, (VkCopyBufferToImageInfo2KHR*)(pCopyBufferToImageInfo));
+                    transform_tohost_VkCopyBufferToImageInfo2(
+                        globalstate, (VkCopyBufferToImageInfo2*)(pCopyBufferToImageInfo));
                 }
                 vk->vkCmdCopyBufferToImage2KHR((VkCommandBuffer)dispatchHandle,
                                                pCopyBufferToImageInfo);
@@ -2254,15 +2764,15 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
             }
             case OP_vkCmdCopyImageToBuffer2KHR: {
                 android::base::beginTrace("vkCmdCopyImageToBuffer2KHR subdecode");
-                const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo;
-                VkCopyImageToBufferInfo2KHR stack_pCopyImageToBufferInfo[1];
-                pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2KHR*)stack_pCopyImageToBufferInfo;
-                reservedunmarshal_VkCopyImageToBufferInfo2KHR(
+                const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
+                VkCopyImageToBufferInfo2 stack_pCopyImageToBufferInfo[1];
+                pCopyImageToBufferInfo = (VkCopyImageToBufferInfo2*)stack_pCopyImageToBufferInfo;
+                reservedunmarshal_VkCopyImageToBufferInfo2(
                     readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                    (VkCopyImageToBufferInfo2KHR*)(pCopyImageToBufferInfo), readStreamPtrPtr);
+                    (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo), readStreamPtrPtr);
                 if (pCopyImageToBufferInfo) {
-                    transform_tohost_VkCopyImageToBufferInfo2KHR(
-                        globalstate, (VkCopyImageToBufferInfo2KHR*)(pCopyImageToBufferInfo));
+                    transform_tohost_VkCopyImageToBufferInfo2(
+                        globalstate, (VkCopyImageToBufferInfo2*)(pCopyImageToBufferInfo));
                 }
                 vk->vkCmdCopyImageToBuffer2KHR((VkCommandBuffer)dispatchHandle,
                                                pCopyImageToBufferInfo);
@@ -2271,15 +2781,15 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
             }
             case OP_vkCmdBlitImage2KHR: {
                 android::base::beginTrace("vkCmdBlitImage2KHR subdecode");
-                const VkBlitImageInfo2KHR* pBlitImageInfo;
-                VkBlitImageInfo2KHR stack_pBlitImageInfo[1];
-                pBlitImageInfo = (VkBlitImageInfo2KHR*)stack_pBlitImageInfo;
-                reservedunmarshal_VkBlitImageInfo2KHR(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                                                      (VkBlitImageInfo2KHR*)(pBlitImageInfo),
-                                                      readStreamPtrPtr);
+                const VkBlitImageInfo2* pBlitImageInfo;
+                VkBlitImageInfo2 stack_pBlitImageInfo[1];
+                pBlitImageInfo = (VkBlitImageInfo2*)stack_pBlitImageInfo;
+                reservedunmarshal_VkBlitImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                   (VkBlitImageInfo2*)(pBlitImageInfo),
+                                                   readStreamPtrPtr);
                 if (pBlitImageInfo) {
-                    transform_tohost_VkBlitImageInfo2KHR(globalstate,
-                                                         (VkBlitImageInfo2KHR*)(pBlitImageInfo));
+                    transform_tohost_VkBlitImageInfo2(globalstate,
+                                                      (VkBlitImageInfo2*)(pBlitImageInfo));
                 }
                 vk->vkCmdBlitImage2KHR((VkCommandBuffer)dispatchHandle, pBlitImageInfo);
                 android::base::endTrace();
@@ -2287,15 +2797,15 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
             }
             case OP_vkCmdResolveImage2KHR: {
                 android::base::beginTrace("vkCmdResolveImage2KHR subdecode");
-                const VkResolveImageInfo2KHR* pResolveImageInfo;
-                VkResolveImageInfo2KHR stack_pResolveImageInfo[1];
-                pResolveImageInfo = (VkResolveImageInfo2KHR*)stack_pResolveImageInfo;
-                reservedunmarshal_VkResolveImageInfo2KHR(
-                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
-                    (VkResolveImageInfo2KHR*)(pResolveImageInfo), readStreamPtrPtr);
+                const VkResolveImageInfo2* pResolveImageInfo;
+                VkResolveImageInfo2 stack_pResolveImageInfo[1];
+                pResolveImageInfo = (VkResolveImageInfo2*)stack_pResolveImageInfo;
+                reservedunmarshal_VkResolveImageInfo2(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                      (VkResolveImageInfo2*)(pResolveImageInfo),
+                                                      readStreamPtrPtr);
                 if (pResolveImageInfo) {
-                    transform_tohost_VkResolveImageInfo2KHR(
-                        globalstate, (VkResolveImageInfo2KHR*)(pResolveImageInfo));
+                    transform_tohost_VkResolveImageInfo2(globalstate,
+                                                         (VkResolveImageInfo2*)(pResolveImageInfo));
                 }
                 vk->vkCmdResolveImage2KHR((VkCommandBuffer)dispatchHandle, pResolveImageInfo);
                 android::base::endTrace();
@@ -2304,8 +2814,25 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_KHR_format_feature_flags2
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+            case OP_vkCmdTraceRaysIndirect2KHR: {
+                android::base::beginTrace("vkCmdTraceRaysIndirect2KHR subdecode");
+                VkDeviceAddress indirectDeviceAddress;
+                memcpy((VkDeviceAddress*)&indirectDeviceAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                vk->vkCmdTraceRaysIndirect2KHR((VkCommandBuffer)dispatchHandle,
+                                               indirectDeviceAddress);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
 #ifdef VK_EXT_debug_report
@@ -2698,8 +3225,6 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_EXT_video_encode_h265
 #endif
-#ifdef VK_EXT_video_decode_h264
-#endif
 #ifdef VK_AMD_texture_gather_bias_lod
 #endif
 #ifdef VK_AMD_shader_info
@@ -2732,6 +3257,8 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_EXT_astc_decode_mode
 #endif
+#ifdef VK_EXT_pipeline_robustness
+#endif
 #ifdef VK_EXT_conditional_rendering
             case OP_vkCmdBeginConditionalRenderingEXT: {
                 android::base::beginTrace("vkCmdBeginConditionalRenderingEXT subdecode");
@@ -2847,6 +3374,27 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
                 android::base::endTrace();
                 break;
             }
+            case OP_vkCmdSetDiscardRectangleEnableEXT: {
+                android::base::beginTrace("vkCmdSetDiscardRectangleEnableEXT subdecode");
+                VkBool32 discardRectangleEnable;
+                memcpy((VkBool32*)&discardRectangleEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDiscardRectangleEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                      discardRectangleEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDiscardRectangleModeEXT: {
+                android::base::beginTrace("vkCmdSetDiscardRectangleModeEXT subdecode");
+                VkDiscardRectangleModeEXT discardRectangleMode;
+                memcpy((VkDiscardRectangleModeEXT*)&discardRectangleMode, *readStreamPtrPtr,
+                       sizeof(VkDiscardRectangleModeEXT));
+                *readStreamPtrPtr += sizeof(VkDiscardRectangleModeEXT);
+                vk->vkCmdSetDiscardRectangleModeEXT((VkCommandBuffer)dispatchHandle,
+                                                    discardRectangleMode);
+                android::base::endTrace();
+                break;
+            }
 #endif
 #ifdef VK_EXT_conservative_rasterization
 #endif
@@ -2860,8 +3408,6 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_MVK_macos_surface
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -3279,8 +3825,6 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_AMD_shader_core_properties
 #endif
-#ifdef VK_EXT_video_decode_h265
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 #endif
 #ifdef VK_EXT_vertex_attribute_divisor
@@ -3363,6 +3907,31 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #ifdef VK_NV_shader_image_footprint
 #endif
 #ifdef VK_NV_scissor_exclusive
+            case OP_vkCmdSetExclusiveScissorEnableNV: {
+                android::base::beginTrace("vkCmdSetExclusiveScissorEnableNV subdecode");
+                uint32_t firstExclusiveScissor;
+                uint32_t exclusiveScissorCount;
+                const VkBool32* pExclusiveScissorEnables;
+                VkBool32 stack_pExclusiveScissorEnables[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstExclusiveScissor, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&exclusiveScissorCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((exclusiveScissorCount)) <= MAX_STACK_ITEMS) {
+                    pExclusiveScissorEnables = (VkBool32*)stack_pExclusiveScissorEnables;
+                } else {
+                    readStream->alloc((void**)&pExclusiveScissorEnables,
+                                      ((exclusiveScissorCount)) * sizeof(const VkBool32));
+                }
+                memcpy((VkBool32*)pExclusiveScissorEnables, *readStreamPtrPtr,
+                       ((exclusiveScissorCount)) * sizeof(const VkBool32));
+                *readStreamPtrPtr += ((exclusiveScissorCount)) * sizeof(const VkBool32);
+                vk->vkCmdSetExclusiveScissorEnableNV((VkCommandBuffer)dispatchHandle,
+                                                     firstExclusiveScissor, exclusiveScissorCount,
+                                                     pExclusiveScissorEnables);
+                android::base::endTrace();
+                break;
+            }
             case OP_vkCmdSetExclusiveScissorNV: {
                 android::base::beginTrace("vkCmdSetExclusiveScissorNV subdecode");
                 uint32_t firstExclusiveScissor;
@@ -3799,6 +4368,10 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_EXT_shader_atomic_float2
 #endif
+#ifdef VK_EXT_surface_maintenance1
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+#endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -3875,6 +4448,8 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+#endif
 #ifdef VK_EXT_private_data
 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
@@ -3883,6 +4458,111 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+#endif
+#ifdef VK_EXT_metal_objects
+#endif
+#ifdef VK_EXT_descriptor_buffer
+            case OP_vkCmdBindDescriptorBuffersEXT: {
+                android::base::beginTrace("vkCmdBindDescriptorBuffersEXT subdecode");
+                uint32_t bufferCount;
+                const VkDescriptorBufferBindingInfoEXT* pBindingInfos;
+                VkDescriptorBufferBindingInfoEXT stack_pBindingInfos[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&bufferCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((bufferCount)) <= MAX_STACK_ITEMS) {
+                    pBindingInfos = (VkDescriptorBufferBindingInfoEXT*)stack_pBindingInfos;
+                } else {
+                    readStream->alloc(
+                        (void**)&pBindingInfos,
+                        ((bufferCount)) * sizeof(const VkDescriptorBufferBindingInfoEXT));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((bufferCount)); ++i) {
+                    reservedunmarshal_VkDescriptorBufferBindingInfoEXT(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkDescriptorBufferBindingInfoEXT*)(pBindingInfos + i), readStreamPtrPtr);
+                }
+                if (pBindingInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((bufferCount)); ++i) {
+                        transform_tohost_VkDescriptorBufferBindingInfoEXT(
+                            globalstate, (VkDescriptorBufferBindingInfoEXT*)(pBindingInfos + i));
+                    }
+                }
+                vk->vkCmdBindDescriptorBuffersEXT((VkCommandBuffer)dispatchHandle, bufferCount,
+                                                  pBindingInfos);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDescriptorBufferOffsetsEXT: {
+                android::base::beginTrace("vkCmdSetDescriptorBufferOffsetsEXT subdecode");
+                VkPipelineBindPoint pipelineBindPoint;
+                VkPipelineLayout layout;
+                uint32_t firstSet;
+                uint32_t setCount;
+                const uint32_t* pBufferIndices;
+                uint32_t stack_pBufferIndices[MAX_STACK_ITEMS];
+                const VkDeviceSize* pOffsets;
+                VkDeviceSize stack_pOffsets[MAX_STACK_ITEMS];
+                memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
+                       sizeof(VkPipelineBindPoint));
+                *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkPipelineLayout*)&layout =
+                    (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
+                memcpy((uint32_t*)&firstSet, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&setCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((setCount)) <= MAX_STACK_ITEMS) {
+                    pBufferIndices = (uint32_t*)stack_pBufferIndices;
+                } else {
+                    readStream->alloc((void**)&pBufferIndices,
+                                      ((setCount)) * sizeof(const uint32_t));
+                }
+                memcpy((uint32_t*)pBufferIndices, *readStreamPtrPtr,
+                       ((setCount)) * sizeof(const uint32_t));
+                *readStreamPtrPtr += ((setCount)) * sizeof(const uint32_t);
+                if (((setCount)) <= MAX_STACK_ITEMS) {
+                    pOffsets = (VkDeviceSize*)stack_pOffsets;
+                } else {
+                    readStream->alloc((void**)&pOffsets, ((setCount)) * sizeof(const VkDeviceSize));
+                }
+                memcpy((VkDeviceSize*)pOffsets, *readStreamPtrPtr,
+                       ((setCount)) * sizeof(const VkDeviceSize));
+                *readStreamPtrPtr += ((setCount)) * sizeof(const VkDeviceSize);
+                vk->vkCmdSetDescriptorBufferOffsetsEXT((VkCommandBuffer)dispatchHandle,
+                                                       pipelineBindPoint, layout, firstSet,
+                                                       setCount, pBufferIndices, pOffsets);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdBindDescriptorBufferEmbeddedSamplersEXT: {
+                android::base::beginTrace("vkCmdBindDescriptorBufferEmbeddedSamplersEXT subdecode");
+                VkPipelineBindPoint pipelineBindPoint;
+                VkPipelineLayout layout;
+                uint32_t set;
+                memcpy((VkPipelineBindPoint*)&pipelineBindPoint, *readStreamPtrPtr,
+                       sizeof(VkPipelineBindPoint));
+                *readStreamPtrPtr += sizeof(VkPipelineBindPoint);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkPipelineLayout*)&layout =
+                    (VkPipelineLayout)unbox_VkPipelineLayout((VkPipelineLayout)(*&cgen_var_0));
+                memcpy((uint32_t*)&set, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdBindDescriptorBufferEmbeddedSamplersEXT((VkCommandBuffer)dispatchHandle,
+                                                                 pipelineBindPoint, layout, set);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
             case OP_vkCmdSetFragmentShadingRateEnumNV: {
                 android::base::beginTrace("vkCmdSetFragmentShadingRateEnumNV subdecode");
@@ -3910,8 +4590,16 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_EXT_image_robustness
 #endif
+#ifdef VK_EXT_image_compression_control
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+#endif
 #ifdef VK_EXT_4444_formats
 #endif
+#ifdef VK_EXT_device_fault
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 #endif
 #ifdef VK_NV_acquire_winrt_display
@@ -3990,6 +4678,10 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_EXT_physical_device_drm
 #endif
+#ifdef VK_EXT_device_address_binding_report
+#endif
+#ifdef VK_EXT_depth_clip_control
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 #endif
 #ifdef VK_FUCHSIA_external_memory
@@ -4026,6 +4718,10 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_NV_external_memory_rdma
 #endif
+#ifdef VK_EXT_pipeline_properties
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
             case OP_vkCmdSetPatchControlPointsEXT: {
                 android::base::beginTrace("vkCmdSetPatchControlPointsEXT subdecode");
@@ -4101,6 +4797,8 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
                 break;
             }
 #endif
+#ifdef VK_EXT_primitives_generated_query
+#endif
 #ifdef VK_GOOGLE_gfxstream
             case OP_vkBeginCommandBufferAsyncGOOGLE: {
                 android::base::beginTrace("vkBeginCommandBufferAsyncGOOGLE subdecode");
@@ -4153,6 +4851,8 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_EXT_global_priority_query
 #endif
+#ifdef VK_EXT_image_view_min_lod
+#endif
 #ifdef VK_EXT_multi_draw
             case OP_vkCmdDrawMultiEXT: {
                 android::base::beginTrace("vkCmdDrawMultiEXT subdecode");
@@ -4254,12 +4954,848 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
                 break;
             }
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+#endif
+#ifdef VK_EXT_shader_tile_image
+#endif
+#ifdef VK_EXT_opacity_micromap
+            case OP_vkCmdBuildMicromapsEXT: {
+                android::base::beginTrace("vkCmdBuildMicromapsEXT subdecode");
+                uint32_t infoCount;
+                const VkMicromapBuildInfoEXT* pInfos;
+                VkMicromapBuildInfoEXT stack_pInfos[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&infoCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((infoCount)) <= MAX_STACK_ITEMS) {
+                    pInfos = (VkMicromapBuildInfoEXT*)stack_pInfos;
+                } else {
+                    readStream->alloc((void**)&pInfos,
+                                      ((infoCount)) * sizeof(const VkMicromapBuildInfoEXT));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+                    reservedunmarshal_VkMicromapBuildInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                             (VkMicromapBuildInfoEXT*)(pInfos + i),
+                                                             readStreamPtrPtr);
+                }
+                if (pInfos) {
+                    for (uint32_t i = 0; i < (uint32_t)((infoCount)); ++i) {
+                        transform_tohost_VkMicromapBuildInfoEXT(
+                            globalstate, (VkMicromapBuildInfoEXT*)(pInfos + i));
+                    }
+                }
+                vk->vkCmdBuildMicromapsEXT((VkCommandBuffer)dispatchHandle, infoCount, pInfos);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyMicromapEXT: {
+                android::base::beginTrace("vkCmdCopyMicromapEXT subdecode");
+                const VkCopyMicromapInfoEXT* pInfo;
+                VkCopyMicromapInfoEXT stack_pInfo[1];
+                pInfo = (VkCopyMicromapInfoEXT*)stack_pInfo;
+                reservedunmarshal_VkCopyMicromapInfoEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                                                        (VkCopyMicromapInfoEXT*)(pInfo),
+                                                        readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyMicromapInfoEXT(globalstate,
+                                                           (VkCopyMicromapInfoEXT*)(pInfo));
+                }
+                vk->vkCmdCopyMicromapEXT((VkCommandBuffer)dispatchHandle, pInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyMicromapToMemoryEXT: {
+                android::base::beginTrace("vkCmdCopyMicromapToMemoryEXT subdecode");
+                const VkCopyMicromapToMemoryInfoEXT* pInfo;
+                VkCopyMicromapToMemoryInfoEXT stack_pInfo[1];
+                pInfo = (VkCopyMicromapToMemoryInfoEXT*)stack_pInfo;
+                reservedunmarshal_VkCopyMicromapToMemoryInfoEXT(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMicromapToMemoryInfoEXT*)(pInfo),
+                    readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyMicromapToMemoryInfoEXT(
+                        globalstate, (VkCopyMicromapToMemoryInfoEXT*)(pInfo));
+                }
+                vk->vkCmdCopyMicromapToMemoryEXT((VkCommandBuffer)dispatchHandle, pInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyMemoryToMicromapEXT: {
+                android::base::beginTrace("vkCmdCopyMemoryToMicromapEXT subdecode");
+                const VkCopyMemoryToMicromapInfoEXT* pInfo;
+                VkCopyMemoryToMicromapInfoEXT stack_pInfo[1];
+                pInfo = (VkCopyMemoryToMicromapInfoEXT*)stack_pInfo;
+                reservedunmarshal_VkCopyMemoryToMicromapInfoEXT(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM, (VkCopyMemoryToMicromapInfoEXT*)(pInfo),
+                    readStreamPtrPtr);
+                if (pInfo) {
+                    transform_tohost_VkCopyMemoryToMicromapInfoEXT(
+                        globalstate, (VkCopyMemoryToMicromapInfoEXT*)(pInfo));
+                }
+                vk->vkCmdCopyMemoryToMicromapEXT((VkCommandBuffer)dispatchHandle, pInfo);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdWriteMicromapsPropertiesEXT: {
+                android::base::beginTrace("vkCmdWriteMicromapsPropertiesEXT subdecode");
+                uint32_t micromapCount;
+                const VkMicromapEXT* pMicromaps;
+                VkMicromapEXT stack_pMicromaps[MAX_STACK_ITEMS];
+                VkQueryType queryType;
+                VkQueryPool queryPool;
+                uint32_t firstQuery;
+                memcpy((uint32_t*)&micromapCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((micromapCount)) <= MAX_STACK_ITEMS) {
+                    pMicromaps = (VkMicromapEXT*)stack_pMicromaps;
+                } else {
+                    readStream->alloc((void**)&pMicromaps,
+                                      ((micromapCount)) * sizeof(const VkMicromapEXT));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((micromapCount)); ++i) {
+                    memcpy((VkMicromapEXT*)&pMicromaps[i], (*readStreamPtrPtr), 8);
+                    android::base::Stream::fromBe64((uint8_t*)&pMicromaps[i]);
+                    *readStreamPtrPtr += 8;
+                }
+                memcpy((VkQueryType*)&queryType, *readStreamPtrPtr, sizeof(VkQueryType));
+                *readStreamPtrPtr += sizeof(VkQueryType);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkQueryPool*)&queryPool =
+                    (VkQueryPool)unbox_VkQueryPool((VkQueryPool)(*&cgen_var_0));
+                memcpy((uint32_t*)&firstQuery, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdWriteMicromapsPropertiesEXT((VkCommandBuffer)dispatchHandle, micromapCount,
+                                                     pMicromaps, queryType, queryPool, firstQuery);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_displacement_micromap
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+            case OP_vkCmdDrawClusterHUAWEI: {
+                android::base::beginTrace("vkCmdDrawClusterHUAWEI subdecode");
+                uint32_t groupCountX;
+                uint32_t groupCountY;
+                uint32_t groupCountZ;
+                memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawClusterHUAWEI((VkCommandBuffer)dispatchHandle, groupCountX,
+                                           groupCountY, groupCountZ);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawClusterIndirectHUAWEI: {
+                android::base::beginTrace("vkCmdDrawClusterIndirectHUAWEI subdecode");
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                vk->vkCmdDrawClusterIndirectHUAWEI((VkCommandBuffer)dispatchHandle, buffer, offset);
+                android::base::endTrace();
+                break;
+            }
+#endif
 #ifdef VK_EXT_border_color_swizzle
 #endif
 #ifdef VK_EXT_pageable_device_local_memory
 #endif
+#ifdef VK_ARM_shader_core_properties
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+#endif
+#ifdef VK_NV_copy_memory_indirect
+            case OP_vkCmdCopyMemoryIndirectNV: {
+                android::base::beginTrace("vkCmdCopyMemoryIndirectNV subdecode");
+                VkDeviceAddress copyBufferAddress;
+                uint32_t copyCount;
+                uint32_t stride;
+                memcpy((VkDeviceAddress*)&copyBufferAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                memcpy((uint32_t*)&copyCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdCopyMemoryIndirectNV((VkCommandBuffer)dispatchHandle, copyBufferAddress,
+                                              copyCount, stride);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdCopyMemoryToImageIndirectNV: {
+                android::base::beginTrace("vkCmdCopyMemoryToImageIndirectNV subdecode");
+                VkDeviceAddress copyBufferAddress;
+                uint32_t copyCount;
+                uint32_t stride;
+                VkImage dstImage;
+                VkImageLayout dstImageLayout;
+                const VkImageSubresourceLayers* pImageSubresources;
+                VkImageSubresourceLayers stack_pImageSubresources[MAX_STACK_ITEMS];
+                memcpy((VkDeviceAddress*)&copyBufferAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                memcpy((uint32_t*)&copyCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkImage*)&dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+                memcpy((VkImageLayout*)&dstImageLayout, *readStreamPtrPtr, sizeof(VkImageLayout));
+                *readStreamPtrPtr += sizeof(VkImageLayout);
+                if (((copyCount)) <= MAX_STACK_ITEMS) {
+                    pImageSubresources = (VkImageSubresourceLayers*)stack_pImageSubresources;
+                } else {
+                    readStream->alloc((void**)&pImageSubresources,
+                                      ((copyCount)) * sizeof(const VkImageSubresourceLayers));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((copyCount)); ++i) {
+                    reservedunmarshal_VkImageSubresourceLayers(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkImageSubresourceLayers*)(pImageSubresources + i), readStreamPtrPtr);
+                }
+                if (pImageSubresources) {
+                    for (uint32_t i = 0; i < (uint32_t)((copyCount)); ++i) {
+                        transform_tohost_VkImageSubresourceLayers(
+                            globalstate, (VkImageSubresourceLayers*)(pImageSubresources + i));
+                    }
+                }
+                vk->vkCmdCopyMemoryToImageIndirectNV((VkCommandBuffer)dispatchHandle,
+                                                     copyBufferAddress, copyCount, stride, dstImage,
+                                                     dstImageLayout, pImageSubresources);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_memory_decompression
+            case OP_vkCmdDecompressMemoryNV: {
+                android::base::beginTrace("vkCmdDecompressMemoryNV subdecode");
+                uint32_t decompressRegionCount;
+                const VkDecompressMemoryRegionNV* pDecompressMemoryRegions;
+                VkDecompressMemoryRegionNV stack_pDecompressMemoryRegions[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&decompressRegionCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((decompressRegionCount)) <= MAX_STACK_ITEMS) {
+                    pDecompressMemoryRegions =
+                        (VkDecompressMemoryRegionNV*)stack_pDecompressMemoryRegions;
+                } else {
+                    readStream->alloc(
+                        (void**)&pDecompressMemoryRegions,
+                        ((decompressRegionCount)) * sizeof(const VkDecompressMemoryRegionNV));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((decompressRegionCount)); ++i) {
+                    reservedunmarshal_VkDecompressMemoryRegionNV(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkDecompressMemoryRegionNV*)(pDecompressMemoryRegions + i),
+                        readStreamPtrPtr);
+                }
+                if (pDecompressMemoryRegions) {
+                    for (uint32_t i = 0; i < (uint32_t)((decompressRegionCount)); ++i) {
+                        transform_tohost_VkDecompressMemoryRegionNV(
+                            globalstate,
+                            (VkDecompressMemoryRegionNV*)(pDecompressMemoryRegions + i));
+                    }
+                }
+                vk->vkCmdDecompressMemoryNV((VkCommandBuffer)dispatchHandle, decompressRegionCount,
+                                            pDecompressMemoryRegions);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDecompressMemoryIndirectCountNV: {
+                android::base::beginTrace("vkCmdDecompressMemoryIndirectCountNV subdecode");
+                VkDeviceAddress indirectCommandsAddress;
+                VkDeviceAddress indirectCommandsCountAddress;
+                uint32_t stride;
+                memcpy((VkDeviceAddress*)&indirectCommandsAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                memcpy((VkDeviceAddress*)&indirectCommandsCountAddress, *readStreamPtrPtr,
+                       sizeof(VkDeviceAddress));
+                *readStreamPtrPtr += sizeof(VkDeviceAddress);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDecompressMemoryIndirectCountNV((VkCommandBuffer)dispatchHandle,
+                                                         indirectCommandsAddress,
+                                                         indirectCommandsCountAddress, stride);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_NV_linear_color_attachment
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+#endif
+#ifdef VK_QCOM_image_processing
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+            case OP_vkCmdSetTessellationDomainOriginEXT: {
+                android::base::beginTrace("vkCmdSetTessellationDomainOriginEXT subdecode");
+                VkTessellationDomainOrigin domainOrigin;
+                memcpy((VkTessellationDomainOrigin*)&domainOrigin, *readStreamPtrPtr,
+                       sizeof(VkTessellationDomainOrigin));
+                *readStreamPtrPtr += sizeof(VkTessellationDomainOrigin);
+                vk->vkCmdSetTessellationDomainOriginEXT((VkCommandBuffer)dispatchHandle,
+                                                        domainOrigin);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthClampEnableEXT: {
+                android::base::beginTrace("vkCmdSetDepthClampEnableEXT subdecode");
+                VkBool32 depthClampEnable;
+                memcpy((VkBool32*)&depthClampEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthClampEnableEXT((VkCommandBuffer)dispatchHandle, depthClampEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetPolygonModeEXT: {
+                android::base::beginTrace("vkCmdSetPolygonModeEXT subdecode");
+                VkPolygonMode polygonMode;
+                memcpy((VkPolygonMode*)&polygonMode, *readStreamPtrPtr, sizeof(VkPolygonMode));
+                *readStreamPtrPtr += sizeof(VkPolygonMode);
+                vk->vkCmdSetPolygonModeEXT((VkCommandBuffer)dispatchHandle, polygonMode);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetRasterizationSamplesEXT: {
+                android::base::beginTrace("vkCmdSetRasterizationSamplesEXT subdecode");
+                VkSampleCountFlagBits rasterizationSamples;
+                memcpy((VkSampleCountFlagBits*)&rasterizationSamples, *readStreamPtrPtr,
+                       sizeof(VkSampleCountFlagBits));
+                *readStreamPtrPtr += sizeof(VkSampleCountFlagBits);
+                vk->vkCmdSetRasterizationSamplesEXT((VkCommandBuffer)dispatchHandle,
+                                                    rasterizationSamples);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetSampleMaskEXT: {
+                android::base::beginTrace("vkCmdSetSampleMaskEXT subdecode");
+                VkSampleCountFlagBits samples;
+                const VkSampleMask* pSampleMask;
+                VkSampleMask stack_pSampleMask[MAX_STACK_ITEMS];
+                memcpy((VkSampleCountFlagBits*)&samples, *readStreamPtrPtr,
+                       sizeof(VkSampleCountFlagBits));
+                *readStreamPtrPtr += sizeof(VkSampleCountFlagBits);
+                if (int(samples / 32) <= MAX_STACK_ITEMS) {
+                    pSampleMask = (VkSampleMask*)stack_pSampleMask;
+                } else {
+                    readStream->alloc((void**)&pSampleMask,
+                                      int(samples / 32) * sizeof(const VkSampleMask));
+                }
+                memcpy((VkSampleMask*)pSampleMask, *readStreamPtrPtr,
+                       int(samples / 32) * sizeof(const VkSampleMask));
+                *readStreamPtrPtr += int(samples / 32) * sizeof(const VkSampleMask);
+                vk->vkCmdSetSampleMaskEXT((VkCommandBuffer)dispatchHandle, samples, pSampleMask);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetAlphaToCoverageEnableEXT: {
+                android::base::beginTrace("vkCmdSetAlphaToCoverageEnableEXT subdecode");
+                VkBool32 alphaToCoverageEnable;
+                memcpy((VkBool32*)&alphaToCoverageEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetAlphaToCoverageEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                     alphaToCoverageEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetAlphaToOneEnableEXT: {
+                android::base::beginTrace("vkCmdSetAlphaToOneEnableEXT subdecode");
+                VkBool32 alphaToOneEnable;
+                memcpy((VkBool32*)&alphaToOneEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetAlphaToOneEnableEXT((VkCommandBuffer)dispatchHandle, alphaToOneEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetLogicOpEnableEXT: {
+                android::base::beginTrace("vkCmdSetLogicOpEnableEXT subdecode");
+                VkBool32 logicOpEnable;
+                memcpy((VkBool32*)&logicOpEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetLogicOpEnableEXT((VkCommandBuffer)dispatchHandle, logicOpEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetColorBlendEnableEXT: {
+                android::base::beginTrace("vkCmdSetColorBlendEnableEXT subdecode");
+                uint32_t firstAttachment;
+                uint32_t attachmentCount;
+                const VkBool32* pColorBlendEnables;
+                VkBool32 stack_pColorBlendEnables[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((attachmentCount)) <= MAX_STACK_ITEMS) {
+                    pColorBlendEnables = (VkBool32*)stack_pColorBlendEnables;
+                } else {
+                    readStream->alloc((void**)&pColorBlendEnables,
+                                      ((attachmentCount)) * sizeof(const VkBool32));
+                }
+                memcpy((VkBool32*)pColorBlendEnables, *readStreamPtrPtr,
+                       ((attachmentCount)) * sizeof(const VkBool32));
+                *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkBool32);
+                vk->vkCmdSetColorBlendEnableEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
+                                                attachmentCount, pColorBlendEnables);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetColorBlendEquationEXT: {
+                android::base::beginTrace("vkCmdSetColorBlendEquationEXT subdecode");
+                uint32_t firstAttachment;
+                uint32_t attachmentCount;
+                const VkColorBlendEquationEXT* pColorBlendEquations;
+                VkColorBlendEquationEXT stack_pColorBlendEquations[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((attachmentCount)) <= MAX_STACK_ITEMS) {
+                    pColorBlendEquations = (VkColorBlendEquationEXT*)stack_pColorBlendEquations;
+                } else {
+                    readStream->alloc((void**)&pColorBlendEquations,
+                                      ((attachmentCount)) * sizeof(const VkColorBlendEquationEXT));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+                    reservedunmarshal_VkColorBlendEquationEXT(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkColorBlendEquationEXT*)(pColorBlendEquations + i), readStreamPtrPtr);
+                }
+                if (pColorBlendEquations) {
+                    for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+                        transform_tohost_VkColorBlendEquationEXT(
+                            globalstate, (VkColorBlendEquationEXT*)(pColorBlendEquations + i));
+                    }
+                }
+                vk->vkCmdSetColorBlendEquationEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
+                                                  attachmentCount, pColorBlendEquations);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetColorWriteMaskEXT: {
+                android::base::beginTrace("vkCmdSetColorWriteMaskEXT subdecode");
+                uint32_t firstAttachment;
+                uint32_t attachmentCount;
+                const VkColorComponentFlags* pColorWriteMasks;
+                VkColorComponentFlags stack_pColorWriteMasks[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                // WARNING PTR CHECK
+                memcpy((VkColorComponentFlags**)&pColorWriteMasks, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pColorWriteMasks);
+                *readStreamPtrPtr += 8;
+                if (pColorWriteMasks) {
+                    if (((attachmentCount)) <= MAX_STACK_ITEMS) {
+                        pColorWriteMasks = (VkColorComponentFlags*)stack_pColorWriteMasks;
+                    } else {
+                        readStream->alloc(
+                            (void**)&pColorWriteMasks,
+                            ((attachmentCount)) * sizeof(const VkColorComponentFlags));
+                    }
+                    memcpy((VkColorComponentFlags*)pColorWriteMasks, *readStreamPtrPtr,
+                           ((attachmentCount)) * sizeof(const VkColorComponentFlags));
+                    *readStreamPtrPtr += ((attachmentCount)) * sizeof(const VkColorComponentFlags);
+                }
+                vk->vkCmdSetColorWriteMaskEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
+                                              attachmentCount, pColorWriteMasks);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetRasterizationStreamEXT: {
+                android::base::beginTrace("vkCmdSetRasterizationStreamEXT subdecode");
+                uint32_t rasterizationStream;
+                memcpy((uint32_t*)&rasterizationStream, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdSetRasterizationStreamEXT((VkCommandBuffer)dispatchHandle,
+                                                   rasterizationStream);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetConservativeRasterizationModeEXT: {
+                android::base::beginTrace("vkCmdSetConservativeRasterizationModeEXT subdecode");
+                VkConservativeRasterizationModeEXT conservativeRasterizationMode;
+                memcpy((VkConservativeRasterizationModeEXT*)&conservativeRasterizationMode,
+                       *readStreamPtrPtr, sizeof(VkConservativeRasterizationModeEXT));
+                *readStreamPtrPtr += sizeof(VkConservativeRasterizationModeEXT);
+                vk->vkCmdSetConservativeRasterizationModeEXT((VkCommandBuffer)dispatchHandle,
+                                                             conservativeRasterizationMode);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetExtraPrimitiveOverestimationSizeEXT: {
+                android::base::beginTrace("vkCmdSetExtraPrimitiveOverestimationSizeEXT subdecode");
+                float extraPrimitiveOverestimationSize;
+                memcpy((float*)&extraPrimitiveOverestimationSize, *readStreamPtrPtr, sizeof(float));
+                *readStreamPtrPtr += sizeof(float);
+                vk->vkCmdSetExtraPrimitiveOverestimationSizeEXT((VkCommandBuffer)dispatchHandle,
+                                                                extraPrimitiveOverestimationSize);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthClipEnableEXT: {
+                android::base::beginTrace("vkCmdSetDepthClipEnableEXT subdecode");
+                VkBool32 depthClipEnable;
+                memcpy((VkBool32*)&depthClipEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthClipEnableEXT((VkCommandBuffer)dispatchHandle, depthClipEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetSampleLocationsEnableEXT: {
+                android::base::beginTrace("vkCmdSetSampleLocationsEnableEXT subdecode");
+                VkBool32 sampleLocationsEnable;
+                memcpy((VkBool32*)&sampleLocationsEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetSampleLocationsEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                     sampleLocationsEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetColorBlendAdvancedEXT: {
+                android::base::beginTrace("vkCmdSetColorBlendAdvancedEXT subdecode");
+                uint32_t firstAttachment;
+                uint32_t attachmentCount;
+                const VkColorBlendAdvancedEXT* pColorBlendAdvanced;
+                VkColorBlendAdvancedEXT stack_pColorBlendAdvanced[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstAttachment, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&attachmentCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((attachmentCount)) <= MAX_STACK_ITEMS) {
+                    pColorBlendAdvanced = (VkColorBlendAdvancedEXT*)stack_pColorBlendAdvanced;
+                } else {
+                    readStream->alloc((void**)&pColorBlendAdvanced,
+                                      ((attachmentCount)) * sizeof(const VkColorBlendAdvancedEXT));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+                    reservedunmarshal_VkColorBlendAdvancedEXT(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkColorBlendAdvancedEXT*)(pColorBlendAdvanced + i), readStreamPtrPtr);
+                }
+                if (pColorBlendAdvanced) {
+                    for (uint32_t i = 0; i < (uint32_t)((attachmentCount)); ++i) {
+                        transform_tohost_VkColorBlendAdvancedEXT(
+                            globalstate, (VkColorBlendAdvancedEXT*)(pColorBlendAdvanced + i));
+                    }
+                }
+                vk->vkCmdSetColorBlendAdvancedEXT((VkCommandBuffer)dispatchHandle, firstAttachment,
+                                                  attachmentCount, pColorBlendAdvanced);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetProvokingVertexModeEXT: {
+                android::base::beginTrace("vkCmdSetProvokingVertexModeEXT subdecode");
+                VkProvokingVertexModeEXT provokingVertexMode;
+                memcpy((VkProvokingVertexModeEXT*)&provokingVertexMode, *readStreamPtrPtr,
+                       sizeof(VkProvokingVertexModeEXT));
+                *readStreamPtrPtr += sizeof(VkProvokingVertexModeEXT);
+                vk->vkCmdSetProvokingVertexModeEXT((VkCommandBuffer)dispatchHandle,
+                                                   provokingVertexMode);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetLineRasterizationModeEXT: {
+                android::base::beginTrace("vkCmdSetLineRasterizationModeEXT subdecode");
+                VkLineRasterizationModeEXT lineRasterizationMode;
+                memcpy((VkLineRasterizationModeEXT*)&lineRasterizationMode, *readStreamPtrPtr,
+                       sizeof(VkLineRasterizationModeEXT));
+                *readStreamPtrPtr += sizeof(VkLineRasterizationModeEXT);
+                vk->vkCmdSetLineRasterizationModeEXT((VkCommandBuffer)dispatchHandle,
+                                                     lineRasterizationMode);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetLineStippleEnableEXT: {
+                android::base::beginTrace("vkCmdSetLineStippleEnableEXT subdecode");
+                VkBool32 stippledLineEnable;
+                memcpy((VkBool32*)&stippledLineEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetLineStippleEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                 stippledLineEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetDepthClipNegativeOneToOneEXT: {
+                android::base::beginTrace("vkCmdSetDepthClipNegativeOneToOneEXT subdecode");
+                VkBool32 negativeOneToOne;
+                memcpy((VkBool32*)&negativeOneToOne, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetDepthClipNegativeOneToOneEXT((VkCommandBuffer)dispatchHandle,
+                                                         negativeOneToOne);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetViewportWScalingEnableNV: {
+                android::base::beginTrace("vkCmdSetViewportWScalingEnableNV subdecode");
+                VkBool32 viewportWScalingEnable;
+                memcpy((VkBool32*)&viewportWScalingEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetViewportWScalingEnableNV((VkCommandBuffer)dispatchHandle,
+                                                     viewportWScalingEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetViewportSwizzleNV: {
+                android::base::beginTrace("vkCmdSetViewportSwizzleNV subdecode");
+                uint32_t firstViewport;
+                uint32_t viewportCount;
+                const VkViewportSwizzleNV* pViewportSwizzles;
+                VkViewportSwizzleNV stack_pViewportSwizzles[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&firstViewport, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&viewportCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((viewportCount)) <= MAX_STACK_ITEMS) {
+                    pViewportSwizzles = (VkViewportSwizzleNV*)stack_pViewportSwizzles;
+                } else {
+                    readStream->alloc((void**)&pViewportSwizzles,
+                                      ((viewportCount)) * sizeof(const VkViewportSwizzleNV));
+                }
+                for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                    reservedunmarshal_VkViewportSwizzleNV(
+                        readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                        (VkViewportSwizzleNV*)(pViewportSwizzles + i), readStreamPtrPtr);
+                }
+                if (pViewportSwizzles) {
+                    for (uint32_t i = 0; i < (uint32_t)((viewportCount)); ++i) {
+                        transform_tohost_VkViewportSwizzleNV(
+                            globalstate, (VkViewportSwizzleNV*)(pViewportSwizzles + i));
+                    }
+                }
+                vk->vkCmdSetViewportSwizzleNV((VkCommandBuffer)dispatchHandle, firstViewport,
+                                              viewportCount, pViewportSwizzles);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageToColorEnableNV: {
+                android::base::beginTrace("vkCmdSetCoverageToColorEnableNV subdecode");
+                VkBool32 coverageToColorEnable;
+                memcpy((VkBool32*)&coverageToColorEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetCoverageToColorEnableNV((VkCommandBuffer)dispatchHandle,
+                                                    coverageToColorEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageToColorLocationNV: {
+                android::base::beginTrace("vkCmdSetCoverageToColorLocationNV subdecode");
+                uint32_t coverageToColorLocation;
+                memcpy((uint32_t*)&coverageToColorLocation, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdSetCoverageToColorLocationNV((VkCommandBuffer)dispatchHandle,
+                                                      coverageToColorLocation);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageModulationModeNV: {
+                android::base::beginTrace("vkCmdSetCoverageModulationModeNV subdecode");
+                VkCoverageModulationModeNV coverageModulationMode;
+                memcpy((VkCoverageModulationModeNV*)&coverageModulationMode, *readStreamPtrPtr,
+                       sizeof(VkCoverageModulationModeNV));
+                *readStreamPtrPtr += sizeof(VkCoverageModulationModeNV);
+                vk->vkCmdSetCoverageModulationModeNV((VkCommandBuffer)dispatchHandle,
+                                                     coverageModulationMode);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageModulationTableEnableNV: {
+                android::base::beginTrace("vkCmdSetCoverageModulationTableEnableNV subdecode");
+                VkBool32 coverageModulationTableEnable;
+                memcpy((VkBool32*)&coverageModulationTableEnable, *readStreamPtrPtr,
+                       sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetCoverageModulationTableEnableNV((VkCommandBuffer)dispatchHandle,
+                                                            coverageModulationTableEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageModulationTableNV: {
+                android::base::beginTrace("vkCmdSetCoverageModulationTableNV subdecode");
+                uint32_t coverageModulationTableCount;
+                const float* pCoverageModulationTable;
+                float stack_pCoverageModulationTable[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&coverageModulationTableCount, *readStreamPtrPtr,
+                       sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((coverageModulationTableCount)) <= MAX_STACK_ITEMS) {
+                    pCoverageModulationTable = (float*)stack_pCoverageModulationTable;
+                } else {
+                    readStream->alloc((void**)&pCoverageModulationTable,
+                                      ((coverageModulationTableCount)) * sizeof(const float));
+                }
+                memcpy((float*)pCoverageModulationTable, *readStreamPtrPtr,
+                       ((coverageModulationTableCount)) * sizeof(const float));
+                *readStreamPtrPtr += ((coverageModulationTableCount)) * sizeof(const float);
+                vk->vkCmdSetCoverageModulationTableNV((VkCommandBuffer)dispatchHandle,
+                                                      coverageModulationTableCount,
+                                                      pCoverageModulationTable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetShadingRateImageEnableNV: {
+                android::base::beginTrace("vkCmdSetShadingRateImageEnableNV subdecode");
+                VkBool32 shadingRateImageEnable;
+                memcpy((VkBool32*)&shadingRateImageEnable, *readStreamPtrPtr, sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetShadingRateImageEnableNV((VkCommandBuffer)dispatchHandle,
+                                                     shadingRateImageEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetRepresentativeFragmentTestEnableNV: {
+                android::base::beginTrace("vkCmdSetRepresentativeFragmentTestEnableNV subdecode");
+                VkBool32 representativeFragmentTestEnable;
+                memcpy((VkBool32*)&representativeFragmentTestEnable, *readStreamPtrPtr,
+                       sizeof(VkBool32));
+                *readStreamPtrPtr += sizeof(VkBool32);
+                vk->vkCmdSetRepresentativeFragmentTestEnableNV((VkCommandBuffer)dispatchHandle,
+                                                               representativeFragmentTestEnable);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdSetCoverageReductionModeNV: {
+                android::base::beginTrace("vkCmdSetCoverageReductionModeNV subdecode");
+                VkCoverageReductionModeNV coverageReductionMode;
+                memcpy((VkCoverageReductionModeNV*)&coverageReductionMode, *readStreamPtrPtr,
+                       sizeof(VkCoverageReductionModeNV));
+                *readStreamPtrPtr += sizeof(VkCoverageReductionModeNV);
+                vk->vkCmdSetCoverageReductionModeNV((VkCommandBuffer)dispatchHandle,
+                                                    coverageReductionMode);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+#endif
+#ifdef VK_EXT_shader_module_identifier
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+            case OP_vkCmdOpticalFlowExecuteNV: {
+                android::base::beginTrace("vkCmdOpticalFlowExecuteNV subdecode");
+                VkOpticalFlowSessionNV session;
+                const VkOpticalFlowExecuteInfoNV* pExecuteInfo;
+                VkOpticalFlowExecuteInfoNV stack_pExecuteInfo[1];
+                memcpy((VkOpticalFlowSessionNV*)&session, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&session);
+                *readStreamPtrPtr += 8;
+                pExecuteInfo = (VkOpticalFlowExecuteInfoNV*)stack_pExecuteInfo;
+                reservedunmarshal_VkOpticalFlowExecuteInfoNV(
+                    readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+                    (VkOpticalFlowExecuteInfoNV*)(pExecuteInfo), readStreamPtrPtr);
+                if (pExecuteInfo) {
+                    transform_tohost_VkOpticalFlowExecuteInfoNV(
+                        globalstate, (VkOpticalFlowExecuteInfoNV*)(pExecuteInfo));
+                }
+                vk->vkCmdOpticalFlowExecuteNV((VkCommandBuffer)dispatchHandle, session,
+                                              pExecuteInfo);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_EXT_legacy_dithering
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+#endif
+#ifdef VK_EXT_shader_object
+            case OP_vkCmdBindShadersEXT: {
+                android::base::beginTrace("vkCmdBindShadersEXT subdecode");
+                uint32_t stageCount;
+                const VkShaderStageFlagBits* pStages;
+                VkShaderStageFlagBits stack_pStages[MAX_STACK_ITEMS];
+                const VkShaderEXT* pShaders;
+                VkShaderEXT stack_pShaders[MAX_STACK_ITEMS];
+                memcpy((uint32_t*)&stageCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                if (((stageCount)) <= MAX_STACK_ITEMS) {
+                    pStages = (VkShaderStageFlagBits*)stack_pStages;
+                } else {
+                    readStream->alloc((void**)&pStages,
+                                      ((stageCount)) * sizeof(const VkShaderStageFlagBits));
+                }
+                memcpy((VkShaderStageFlagBits*)pStages, *readStreamPtrPtr,
+                       ((stageCount)) * sizeof(const VkShaderStageFlagBits));
+                *readStreamPtrPtr += ((stageCount)) * sizeof(const VkShaderStageFlagBits);
+                // WARNING PTR CHECK
+                memcpy((VkShaderEXT**)&pShaders, (*readStreamPtrPtr), 8);
+                android::base::Stream::fromBe64((uint8_t*)&pShaders);
+                *readStreamPtrPtr += 8;
+                if (pShaders) {
+                    if (((stageCount)) <= MAX_STACK_ITEMS) {
+                        pShaders = (VkShaderEXT*)stack_pShaders;
+                    } else {
+                        readStream->alloc((void**)&pShaders,
+                                          ((stageCount)) * sizeof(const VkShaderEXT));
+                    }
+                    for (uint32_t i = 0; i < (uint32_t)((stageCount)); ++i) {
+                        memcpy((VkShaderEXT*)&pShaders[i], (*readStreamPtrPtr), 8);
+                        android::base::Stream::fromBe64((uint8_t*)&pShaders[i]);
+                        *readStreamPtrPtr += 8;
+                    }
+                }
+                vk->vkCmdBindShadersEXT((VkCommandBuffer)dispatchHandle, stageCount, pStages,
+                                        pShaders);
+                android::base::endTrace();
+                break;
+            }
+#endif
+#ifdef VK_QCOM_tile_properties
+#endif
+#ifdef VK_SEC_amigo_profiling
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+            case OP_vkCmdSetAttachmentFeedbackLoopEnableEXT: {
+                android::base::beginTrace("vkCmdSetAttachmentFeedbackLoopEnableEXT subdecode");
+                VkImageAspectFlags aspectMask;
+                memcpy((VkImageAspectFlags*)&aspectMask, *readStreamPtrPtr,
+                       sizeof(VkImageAspectFlags));
+                *readStreamPtrPtr += sizeof(VkImageAspectFlags);
+                vk->vkCmdSetAttachmentFeedbackLoopEnableEXT((VkCommandBuffer)dispatchHandle,
+                                                            aspectMask);
+                android::base::endTrace();
+                break;
+            }
+#endif
 #ifdef VK_KHR_acceleration_structure
             case OP_vkCmdBuildAccelerationStructuresKHR: {
                 android::base::beginTrace("vkCmdBuildAccelerationStructuresKHR subdecode");
@@ -4588,6 +6124,75 @@ size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* b
 #endif
 #ifdef VK_KHR_ray_query
 #endif
+#ifdef VK_EXT_mesh_shader
+            case OP_vkCmdDrawMeshTasksEXT: {
+                android::base::beginTrace("vkCmdDrawMeshTasksEXT subdecode");
+                uint32_t groupCountX;
+                uint32_t groupCountY;
+                uint32_t groupCountZ;
+                memcpy((uint32_t*)&groupCountX, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountY, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&groupCountZ, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawMeshTasksEXT((VkCommandBuffer)dispatchHandle, groupCountX, groupCountY,
+                                          groupCountZ);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawMeshTasksIndirectEXT: {
+                android::base::beginTrace("vkCmdDrawMeshTasksIndirectEXT subdecode");
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                uint32_t drawCount;
+                uint32_t stride;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&drawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawMeshTasksIndirectEXT((VkCommandBuffer)dispatchHandle, buffer, offset,
+                                                  drawCount, stride);
+                android::base::endTrace();
+                break;
+            }
+            case OP_vkCmdDrawMeshTasksIndirectCountEXT: {
+                android::base::beginTrace("vkCmdDrawMeshTasksIndirectCountEXT subdecode");
+                VkBuffer buffer;
+                VkDeviceSize offset;
+                VkBuffer countBuffer;
+                VkDeviceSize countBufferOffset;
+                uint32_t maxDrawCount;
+                uint32_t stride;
+                uint64_t cgen_var_0;
+                memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+                memcpy((VkDeviceSize*)&offset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                uint64_t cgen_var_1;
+                memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+                *readStreamPtrPtr += 1 * 8;
+                *(VkBuffer*)&countBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+                memcpy((VkDeviceSize*)&countBufferOffset, *readStreamPtrPtr, sizeof(VkDeviceSize));
+                *readStreamPtrPtr += sizeof(VkDeviceSize);
+                memcpy((uint32_t*)&maxDrawCount, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                memcpy((uint32_t*)&stride, *readStreamPtrPtr, sizeof(uint32_t));
+                *readStreamPtrPtr += sizeof(uint32_t);
+                vk->vkCmdDrawMeshTasksIndirectCountEXT((VkCommandBuffer)dispatchHandle, buffer,
+                                                       offset, countBuffer, countBufferOffset,
+                                                       maxDrawCount, stride);
+                android::base::endTrace();
+                break;
+            }
+#endif
             default: {
                 GFXSTREAM_ABORT(::emugl::FatalError(::emugl::ABORT_REASON_OTHER))
                     << "Unrecognized opcode " << opcode;
diff --git a/stream-servers/vulkan/VulkanHandles.h b/stream-servers/vulkan/VulkanHandles.h
index 29cfc1bb..d6578ec1 100644
--- a/stream-servers/vulkan/VulkanHandles.h
+++ b/stream-servers/vulkan/VulkanHandles.h
@@ -56,7 +56,8 @@
     f(VkIndirectCommandsLayoutNV)                                 \
     f(VkAccelerationStructureKHR)                                 \
     f(VkCuModuleNVX)                                              \
-    f(VkCuFunctionNVX)
+    f(VkCuFunctionNVX)                                            \
+    f(VkMicromapEXT)
 
 #define GOLDFISH_VK_LIST_NON_DISPATCHABLE_HANDLE_TYPES(f) \
     f(VkDeviceMemory)                                     \
@@ -105,4 +106,5 @@
     f(VkIndirectCommandsLayoutNV)                 \
     f(VkAccelerationStructureKHR)                 \
     f(VkCuModuleNVX)                              \
-    f(VkCuFunctionNVX)
+    f(VkCuFunctionNVX)                            \
+    f(VkMicromapEXT)
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_deepcopy.cpp b/stream-servers/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
index 9b6bab70..cb7a2307 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_deepcopy
 //
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (impl) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -5087,6 +5087,1421 @@ void deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(
 }
 
 #endif
+#ifdef VK_VERSION_1_3
+void deepcopy_VkPhysicalDeviceVulkan13Features(Allocator* alloc, VkStructureType rootType,
+                                               const VkPhysicalDeviceVulkan13Features* from,
+                                               VkPhysicalDeviceVulkan13Features* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceVulkan13Properties(Allocator* alloc, VkStructureType rootType,
+                                                 const VkPhysicalDeviceVulkan13Properties* from,
+                                                 VkPhysicalDeviceVulkan13Properties* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPipelineCreationFeedback(Allocator* alloc, VkStructureType rootType,
+                                         const VkPipelineCreationFeedback* from,
+                                         VkPipelineCreationFeedback* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+}
+
+void deepcopy_VkPipelineCreationFeedbackCreateInfo(Allocator* alloc, VkStructureType rootType,
+                                                   const VkPipelineCreationFeedbackCreateInfo* from,
+                                                   VkPipelineCreationFeedbackCreateInfo* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pPipelineCreationFeedback = nullptr;
+    if (from->pPipelineCreationFeedback) {
+        to->pPipelineCreationFeedback =
+            (VkPipelineCreationFeedback*)alloc->alloc(sizeof(VkPipelineCreationFeedback));
+        deepcopy_VkPipelineCreationFeedback(
+            alloc, rootType, from->pPipelineCreationFeedback,
+            (VkPipelineCreationFeedback*)(to->pPipelineCreationFeedback));
+    }
+    if (from) {
+        to->pPipelineStageCreationFeedbacks = nullptr;
+        if (from->pPipelineStageCreationFeedbacks) {
+            to->pPipelineStageCreationFeedbacks = (VkPipelineCreationFeedback*)alloc->alloc(
+                from->pipelineStageCreationFeedbackCount * sizeof(VkPipelineCreationFeedback));
+            to->pipelineStageCreationFeedbackCount = from->pipelineStageCreationFeedbackCount;
+            for (uint32_t i = 0; i < (uint32_t)from->pipelineStageCreationFeedbackCount; ++i) {
+                deepcopy_VkPipelineCreationFeedback(
+                    alloc, rootType, from->pPipelineStageCreationFeedbacks + i,
+                    (VkPipelineCreationFeedback*)(to->pPipelineStageCreationFeedbacks + i));
+            }
+        }
+    }
+}
+
+void deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderTerminateInvocationFeatures* from,
+    VkPhysicalDeviceShaderTerminateInvocationFeatures* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceToolProperties(Allocator* alloc, VkStructureType rootType,
+                                             const VkPhysicalDeviceToolProperties* from,
+                                             VkPhysicalDeviceToolProperties* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    memcpy(to->name, from->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    memcpy(to->version, from->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    memcpy(to->layer, from->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+}
+
+void deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* from,
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDevicePrivateDataFeatures(Allocator* alloc, VkStructureType rootType,
+                                                  const VkPhysicalDevicePrivateDataFeatures* from,
+                                                  VkPhysicalDevicePrivateDataFeatures* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDevicePrivateDataCreateInfo(Allocator* alloc, VkStructureType rootType,
+                                            const VkDevicePrivateDataCreateInfo* from,
+                                            VkDevicePrivateDataCreateInfo* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPrivateDataSlotCreateInfo(Allocator* alloc, VkStructureType rootType,
+                                          const VkPrivateDataSlotCreateInfo* from,
+                                          VkPrivateDataSlotCreateInfo* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePipelineCreationCacheControlFeatures* from,
+    VkPhysicalDevicePipelineCreationCacheControlFeatures* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMemoryBarrier2(Allocator* alloc, VkStructureType rootType,
+                               const VkMemoryBarrier2* from, VkMemoryBarrier2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkBufferMemoryBarrier2(Allocator* alloc, VkStructureType rootType,
+                                     const VkBufferMemoryBarrier2* from,
+                                     VkBufferMemoryBarrier2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImageMemoryBarrier2(Allocator* alloc, VkStructureType rootType,
+                                    const VkImageMemoryBarrier2* from, VkImageMemoryBarrier2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkImageSubresourceRange(alloc, rootType, &from->subresourceRange,
+                                     (VkImageSubresourceRange*)(&to->subresourceRange));
+}
+
+void deepcopy_VkDependencyInfo(Allocator* alloc, VkStructureType rootType,
+                               const VkDependencyInfo* from, VkDependencyInfo* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pMemoryBarriers = nullptr;
+        if (from->pMemoryBarriers) {
+            to->pMemoryBarriers = (VkMemoryBarrier2*)alloc->alloc(from->memoryBarrierCount *
+                                                                  sizeof(const VkMemoryBarrier2));
+            to->memoryBarrierCount = from->memoryBarrierCount;
+            for (uint32_t i = 0; i < (uint32_t)from->memoryBarrierCount; ++i) {
+                deepcopy_VkMemoryBarrier2(alloc, rootType, from->pMemoryBarriers + i,
+                                          (VkMemoryBarrier2*)(to->pMemoryBarriers + i));
+            }
+        }
+    }
+    if (from) {
+        to->pBufferMemoryBarriers = nullptr;
+        if (from->pBufferMemoryBarriers) {
+            to->pBufferMemoryBarriers = (VkBufferMemoryBarrier2*)alloc->alloc(
+                from->bufferMemoryBarrierCount * sizeof(const VkBufferMemoryBarrier2));
+            to->bufferMemoryBarrierCount = from->bufferMemoryBarrierCount;
+            for (uint32_t i = 0; i < (uint32_t)from->bufferMemoryBarrierCount; ++i) {
+                deepcopy_VkBufferMemoryBarrier2(
+                    alloc, rootType, from->pBufferMemoryBarriers + i,
+                    (VkBufferMemoryBarrier2*)(to->pBufferMemoryBarriers + i));
+            }
+        }
+    }
+    if (from) {
+        to->pImageMemoryBarriers = nullptr;
+        if (from->pImageMemoryBarriers) {
+            to->pImageMemoryBarriers = (VkImageMemoryBarrier2*)alloc->alloc(
+                from->imageMemoryBarrierCount * sizeof(const VkImageMemoryBarrier2));
+            to->imageMemoryBarrierCount = from->imageMemoryBarrierCount;
+            for (uint32_t i = 0; i < (uint32_t)from->imageMemoryBarrierCount; ++i) {
+                deepcopy_VkImageMemoryBarrier2(
+                    alloc, rootType, from->pImageMemoryBarriers + i,
+                    (VkImageMemoryBarrier2*)(to->pImageMemoryBarriers + i));
+            }
+        }
+    }
+}
+
+void deepcopy_VkSemaphoreSubmitInfo(Allocator* alloc, VkStructureType rootType,
+                                    const VkSemaphoreSubmitInfo* from, VkSemaphoreSubmitInfo* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkCommandBufferSubmitInfo(Allocator* alloc, VkStructureType rootType,
+                                        const VkCommandBufferSubmitInfo* from,
+                                        VkCommandBufferSubmitInfo* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkSubmitInfo2(Allocator* alloc, VkStructureType rootType, const VkSubmitInfo2* from,
+                            VkSubmitInfo2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pWaitSemaphoreInfos = nullptr;
+        if (from->pWaitSemaphoreInfos) {
+            to->pWaitSemaphoreInfos = (VkSemaphoreSubmitInfo*)alloc->alloc(
+                from->waitSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfo));
+            to->waitSemaphoreInfoCount = from->waitSemaphoreInfoCount;
+            for (uint32_t i = 0; i < (uint32_t)from->waitSemaphoreInfoCount; ++i) {
+                deepcopy_VkSemaphoreSubmitInfo(
+                    alloc, rootType, from->pWaitSemaphoreInfos + i,
+                    (VkSemaphoreSubmitInfo*)(to->pWaitSemaphoreInfos + i));
+            }
+        }
+    }
+    if (from) {
+        to->pCommandBufferInfos = nullptr;
+        if (from->pCommandBufferInfos) {
+            to->pCommandBufferInfos = (VkCommandBufferSubmitInfo*)alloc->alloc(
+                from->commandBufferInfoCount * sizeof(const VkCommandBufferSubmitInfo));
+            to->commandBufferInfoCount = from->commandBufferInfoCount;
+            for (uint32_t i = 0; i < (uint32_t)from->commandBufferInfoCount; ++i) {
+                deepcopy_VkCommandBufferSubmitInfo(
+                    alloc, rootType, from->pCommandBufferInfos + i,
+                    (VkCommandBufferSubmitInfo*)(to->pCommandBufferInfos + i));
+            }
+        }
+    }
+    if (from) {
+        to->pSignalSemaphoreInfos = nullptr;
+        if (from->pSignalSemaphoreInfos) {
+            to->pSignalSemaphoreInfos = (VkSemaphoreSubmitInfo*)alloc->alloc(
+                from->signalSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfo));
+            to->signalSemaphoreInfoCount = from->signalSemaphoreInfoCount;
+            for (uint32_t i = 0; i < (uint32_t)from->signalSemaphoreInfoCount; ++i) {
+                deepcopy_VkSemaphoreSubmitInfo(
+                    alloc, rootType, from->pSignalSemaphoreInfos + i,
+                    (VkSemaphoreSubmitInfo*)(to->pSignalSemaphoreInfos + i));
+            }
+        }
+    }
+}
+
+void deepcopy_VkPhysicalDeviceSynchronization2Features(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceSynchronization2Features* from,
+    VkPhysicalDeviceSynchronization2Features* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* from,
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceImageRobustnessFeatures(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceImageRobustnessFeatures* from,
+    VkPhysicalDeviceImageRobustnessFeatures* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkBufferCopy2(Allocator* alloc, VkStructureType rootType, const VkBufferCopy2* from,
+                            VkBufferCopy2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkCopyBufferInfo2(Allocator* alloc, VkStructureType rootType,
+                                const VkCopyBufferInfo2* from, VkCopyBufferInfo2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pRegions = nullptr;
+        if (from->pRegions) {
+            to->pRegions =
+                (VkBufferCopy2*)alloc->alloc(from->regionCount * sizeof(const VkBufferCopy2));
+            to->regionCount = from->regionCount;
+            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+                deepcopy_VkBufferCopy2(alloc, rootType, from->pRegions + i,
+                                       (VkBufferCopy2*)(to->pRegions + i));
+            }
+        }
+    }
+}
+
+void deepcopy_VkImageCopy2(Allocator* alloc, VkStructureType rootType, const VkImageCopy2* from,
+                           VkImageCopy2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource,
+                                      (VkImageSubresourceLayers*)(&to->srcSubresource));
+    deepcopy_VkOffset3D(alloc, rootType, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
+    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource,
+                                      (VkImageSubresourceLayers*)(&to->dstSubresource));
+    deepcopy_VkOffset3D(alloc, rootType, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
+    deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
+}
+
+void deepcopy_VkCopyImageInfo2(Allocator* alloc, VkStructureType rootType,
+                               const VkCopyImageInfo2* from, VkCopyImageInfo2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pRegions = nullptr;
+        if (from->pRegions) {
+            to->pRegions =
+                (VkImageCopy2*)alloc->alloc(from->regionCount * sizeof(const VkImageCopy2));
+            to->regionCount = from->regionCount;
+            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+                deepcopy_VkImageCopy2(alloc, rootType, from->pRegions + i,
+                                      (VkImageCopy2*)(to->pRegions + i));
+            }
+        }
+    }
+}
+
+void deepcopy_VkBufferImageCopy2(Allocator* alloc, VkStructureType rootType,
+                                 const VkBufferImageCopy2* from, VkBufferImageCopy2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->imageSubresource,
+                                      (VkImageSubresourceLayers*)(&to->imageSubresource));
+    deepcopy_VkOffset3D(alloc, rootType, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
+    deepcopy_VkExtent3D(alloc, rootType, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
+}
+
+void deepcopy_VkCopyBufferToImageInfo2(Allocator* alloc, VkStructureType rootType,
+                                       const VkCopyBufferToImageInfo2* from,
+                                       VkCopyBufferToImageInfo2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pRegions = nullptr;
+        if (from->pRegions) {
+            to->pRegions = (VkBufferImageCopy2*)alloc->alloc(from->regionCount *
+                                                             sizeof(const VkBufferImageCopy2));
+            to->regionCount = from->regionCount;
+            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+                deepcopy_VkBufferImageCopy2(alloc, rootType, from->pRegions + i,
+                                            (VkBufferImageCopy2*)(to->pRegions + i));
+            }
+        }
+    }
+}
+
+void deepcopy_VkCopyImageToBufferInfo2(Allocator* alloc, VkStructureType rootType,
+                                       const VkCopyImageToBufferInfo2* from,
+                                       VkCopyImageToBufferInfo2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pRegions = nullptr;
+        if (from->pRegions) {
+            to->pRegions = (VkBufferImageCopy2*)alloc->alloc(from->regionCount *
+                                                             sizeof(const VkBufferImageCopy2));
+            to->regionCount = from->regionCount;
+            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+                deepcopy_VkBufferImageCopy2(alloc, rootType, from->pRegions + i,
+                                            (VkBufferImageCopy2*)(to->pRegions + i));
+            }
+        }
+    }
+}
+
+void deepcopy_VkImageBlit2(Allocator* alloc, VkStructureType rootType, const VkImageBlit2* from,
+                           VkImageBlit2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource,
+                                      (VkImageSubresourceLayers*)(&to->srcSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        deepcopy_VkOffset3D(alloc, rootType, from->srcOffsets + i,
+                            (VkOffset3D*)(to->srcOffsets + i));
+    }
+    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource,
+                                      (VkImageSubresourceLayers*)(&to->dstSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        deepcopy_VkOffset3D(alloc, rootType, from->dstOffsets + i,
+                            (VkOffset3D*)(to->dstOffsets + i));
+    }
+}
+
+void deepcopy_VkBlitImageInfo2(Allocator* alloc, VkStructureType rootType,
+                               const VkBlitImageInfo2* from, VkBlitImageInfo2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pRegions = nullptr;
+        if (from->pRegions) {
+            to->pRegions =
+                (VkImageBlit2*)alloc->alloc(from->regionCount * sizeof(const VkImageBlit2));
+            to->regionCount = from->regionCount;
+            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+                deepcopy_VkImageBlit2(alloc, rootType, from->pRegions + i,
+                                      (VkImageBlit2*)(to->pRegions + i));
+            }
+        }
+    }
+}
+
+void deepcopy_VkImageResolve2(Allocator* alloc, VkStructureType rootType,
+                              const VkImageResolve2* from, VkImageResolve2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource,
+                                      (VkImageSubresourceLayers*)(&to->srcSubresource));
+    deepcopy_VkOffset3D(alloc, rootType, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
+    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource,
+                                      (VkImageSubresourceLayers*)(&to->dstSubresource));
+    deepcopy_VkOffset3D(alloc, rootType, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
+    deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
+}
+
+void deepcopy_VkResolveImageInfo2(Allocator* alloc, VkStructureType rootType,
+                                  const VkResolveImageInfo2* from, VkResolveImageInfo2* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pRegions = nullptr;
+        if (from->pRegions) {
+            to->pRegions =
+                (VkImageResolve2*)alloc->alloc(from->regionCount * sizeof(const VkImageResolve2));
+            to->regionCount = from->regionCount;
+            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+                deepcopy_VkImageResolve2(alloc, rootType, from->pRegions + i,
+                                         (VkImageResolve2*)(to->pRegions + i));
+            }
+        }
+    }
+}
+
+void deepcopy_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceSubgroupSizeControlFeatures* from,
+    VkPhysicalDeviceSubgroupSizeControlFeatures* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceSubgroupSizeControlProperties(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceSubgroupSizeControlProperties* from,
+    VkPhysicalDeviceSubgroupSizeControlProperties* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* from,
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceInlineUniformBlockFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceInlineUniformBlockFeatures* from,
+    VkPhysicalDeviceInlineUniformBlockFeatures* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceInlineUniformBlockProperties(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceInlineUniformBlockProperties* from,
+    VkPhysicalDeviceInlineUniformBlockProperties* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkWriteDescriptorSetInlineUniformBlock(
+    Allocator* alloc, VkStructureType rootType, const VkWriteDescriptorSetInlineUniformBlock* from,
+    VkWriteDescriptorSetInlineUniformBlock* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pData = nullptr;
+    if (from->pData) {
+        to->pData = (void*)alloc->dupArray(from->pData, from->dataSize * sizeof(const uint8_t));
+    }
+}
+
+void deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    Allocator* alloc, VkStructureType rootType,
+    const VkDescriptorPoolInlineUniformBlockCreateInfo* from,
+    VkDescriptorPoolInlineUniformBlockCreateInfo* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* from,
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkRenderingAttachmentInfo(Allocator* alloc, VkStructureType rootType,
+                                        const VkRenderingAttachmentInfo* from,
+                                        VkRenderingAttachmentInfo* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkClearValue(alloc, rootType, &from->clearValue, (VkClearValue*)(&to->clearValue));
+}
+
+void deepcopy_VkRenderingInfo(Allocator* alloc, VkStructureType rootType,
+                              const VkRenderingInfo* from, VkRenderingInfo* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkRect2D(alloc, rootType, &from->renderArea, (VkRect2D*)(&to->renderArea));
+    if (from) {
+        to->pColorAttachments = nullptr;
+        if (from->pColorAttachments) {
+            to->pColorAttachments = (VkRenderingAttachmentInfo*)alloc->alloc(
+                from->colorAttachmentCount * sizeof(const VkRenderingAttachmentInfo));
+            to->colorAttachmentCount = from->colorAttachmentCount;
+            for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i) {
+                deepcopy_VkRenderingAttachmentInfo(
+                    alloc, rootType, from->pColorAttachments + i,
+                    (VkRenderingAttachmentInfo*)(to->pColorAttachments + i));
+            }
+        }
+    }
+    to->pDepthAttachment = nullptr;
+    if (from->pDepthAttachment) {
+        to->pDepthAttachment =
+            (VkRenderingAttachmentInfo*)alloc->alloc(sizeof(const VkRenderingAttachmentInfo));
+        deepcopy_VkRenderingAttachmentInfo(alloc, rootType, from->pDepthAttachment,
+                                           (VkRenderingAttachmentInfo*)(to->pDepthAttachment));
+    }
+    to->pStencilAttachment = nullptr;
+    if (from->pStencilAttachment) {
+        to->pStencilAttachment =
+            (VkRenderingAttachmentInfo*)alloc->alloc(sizeof(const VkRenderingAttachmentInfo));
+        deepcopy_VkRenderingAttachmentInfo(alloc, rootType, from->pStencilAttachment,
+                                           (VkRenderingAttachmentInfo*)(to->pStencilAttachment));
+    }
+}
+
+void deepcopy_VkPipelineRenderingCreateInfo(Allocator* alloc, VkStructureType rootType,
+                                            const VkPipelineRenderingCreateInfo* from,
+                                            VkPipelineRenderingCreateInfo* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pColorAttachmentFormats = nullptr;
+    if (from->pColorAttachmentFormats) {
+        to->pColorAttachmentFormats = (VkFormat*)alloc->dupArray(
+            from->pColorAttachmentFormats, from->colorAttachmentCount * sizeof(const VkFormat));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceDynamicRenderingFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDynamicRenderingFeatures* from,
+    VkPhysicalDeviceDynamicRenderingFeatures* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkCommandBufferInheritanceRenderingInfo(
+    Allocator* alloc, VkStructureType rootType, const VkCommandBufferInheritanceRenderingInfo* from,
+    VkCommandBufferInheritanceRenderingInfo* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pColorAttachmentFormats = nullptr;
+    if (from->pColorAttachmentFormats) {
+        to->pColorAttachmentFormats = (VkFormat*)alloc->dupArray(
+            from->pColorAttachmentFormats, from->colorAttachmentCount * sizeof(const VkFormat));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderIntegerDotProductFeatures* from,
+    VkPhysicalDeviceShaderIntegerDotProductFeatures* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderIntegerDotProductProperties* from,
+    VkPhysicalDeviceShaderIntegerDotProductProperties* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceTexelBufferAlignmentProperties* from,
+    VkPhysicalDeviceTexelBufferAlignmentProperties* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkFormatProperties3(Allocator* alloc, VkStructureType rootType,
+                                  const VkFormatProperties3* from, VkFormatProperties3* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceMaintenance4Features(Allocator* alloc, VkStructureType rootType,
+                                                   const VkPhysicalDeviceMaintenance4Features* from,
+                                                   VkPhysicalDeviceMaintenance4Features* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceMaintenance4Properties(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance4Properties* from,
+    VkPhysicalDeviceMaintenance4Properties* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDeviceBufferMemoryRequirements(Allocator* alloc, VkStructureType rootType,
+                                               const VkDeviceBufferMemoryRequirements* from,
+                                               VkDeviceBufferMemoryRequirements* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pCreateInfo = nullptr;
+    if (from->pCreateInfo) {
+        to->pCreateInfo = (VkBufferCreateInfo*)alloc->alloc(sizeof(const VkBufferCreateInfo));
+        deepcopy_VkBufferCreateInfo(alloc, rootType, from->pCreateInfo,
+                                    (VkBufferCreateInfo*)(to->pCreateInfo));
+    }
+}
+
+void deepcopy_VkDeviceImageMemoryRequirements(Allocator* alloc, VkStructureType rootType,
+                                              const VkDeviceImageMemoryRequirements* from,
+                                              VkDeviceImageMemoryRequirements* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pCreateInfo = nullptr;
+    if (from->pCreateInfo) {
+        to->pCreateInfo = (VkImageCreateInfo*)alloc->alloc(sizeof(const VkImageCreateInfo));
+        deepcopy_VkImageCreateInfo(alloc, rootType, from->pCreateInfo,
+                                   (VkImageCreateInfo*)(to->pCreateInfo));
+    }
+}
+
+#endif
 #ifdef VK_KHR_surface
 void deepcopy_VkSurfaceCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
                                        const VkSurfaceCapabilitiesKHR* from,
@@ -5594,9 +7009,10 @@ void deepcopy_VkWin32SurfaceCreateInfoKHR(Allocator* alloc, VkStructureType root
 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
 #endif
 #ifdef VK_KHR_video_queue
-void deepcopy_VkVideoQueueFamilyProperties2KHR(Allocator* alloc, VkStructureType rootType,
-                                               const VkVideoQueueFamilyProperties2KHR* from,
-                                               VkVideoQueueFamilyProperties2KHR* to) {
+void deepcopy_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkQueueFamilyQueryResultStatusPropertiesKHR* from,
+    VkQueueFamilyQueryResultStatusPropertiesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -5616,8 +7032,9 @@ void deepcopy_VkVideoQueueFamilyProperties2KHR(Allocator* alloc, VkStructureType
     }
 }
 
-void deepcopy_VkVideoProfileKHR(Allocator* alloc, VkStructureType rootType,
-                                const VkVideoProfileKHR* from, VkVideoProfileKHR* to) {
+void deepcopy_VkQueueFamilyVideoPropertiesKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkQueueFamilyVideoPropertiesKHR* from,
+                                              VkQueueFamilyVideoPropertiesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -5637,8 +7054,8 @@ void deepcopy_VkVideoProfileKHR(Allocator* alloc, VkStructureType rootType,
     }
 }
 
-void deepcopy_VkVideoProfilesKHR(Allocator* alloc, VkStructureType rootType,
-                                 const VkVideoProfilesKHR* from, VkVideoProfilesKHR* to) {
+void deepcopy_VkVideoProfileInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                    const VkVideoProfileInfoKHR* from, VkVideoProfileInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -5656,11 +7073,39 @@ void deepcopy_VkVideoProfilesKHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pProfiles = nullptr;
-    if (from->pProfiles) {
-        to->pProfiles = (VkVideoProfileKHR*)alloc->alloc(sizeof(const VkVideoProfileKHR));
-        deepcopy_VkVideoProfileKHR(alloc, rootType, from->pProfiles,
-                                   (VkVideoProfileKHR*)(to->pProfiles));
+}
+
+void deepcopy_VkVideoProfileListInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                        const VkVideoProfileListInfoKHR* from,
+                                        VkVideoProfileListInfoKHR* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pProfiles = nullptr;
+        if (from->pProfiles) {
+            to->pProfiles = (VkVideoProfileInfoKHR*)alloc->alloc(
+                from->profileCount * sizeof(const VkVideoProfileInfoKHR));
+            to->profileCount = from->profileCount;
+            for (uint32_t i = 0; i < (uint32_t)from->profileCount; ++i) {
+                deepcopy_VkVideoProfileInfoKHR(alloc, rootType, from->pProfiles + i,
+                                               (VkVideoProfileInfoKHR*)(to->pProfiles + i));
+            }
+        }
     }
 }
 
@@ -5684,10 +7129,12 @@ void deepcopy_VkVideoCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkExtent2D(alloc, rootType, &from->videoPictureExtentGranularity,
-                        (VkExtent2D*)(&to->videoPictureExtentGranularity));
-    deepcopy_VkExtent2D(alloc, rootType, &from->minExtent, (VkExtent2D*)(&to->minExtent));
-    deepcopy_VkExtent2D(alloc, rootType, &from->maxExtent, (VkExtent2D*)(&to->maxExtent));
+    deepcopy_VkExtent2D(alloc, rootType, &from->pictureAccessGranularity,
+                        (VkExtent2D*)(&to->pictureAccessGranularity));
+    deepcopy_VkExtent2D(alloc, rootType, &from->minCodedExtent, (VkExtent2D*)(&to->minCodedExtent));
+    deepcopy_VkExtent2D(alloc, rootType, &from->maxCodedExtent, (VkExtent2D*)(&to->maxCodedExtent));
+    deepcopy_VkExtensionProperties(alloc, rootType, &from->stdHeaderVersion,
+                                   (VkExtensionProperties*)(&to->stdHeaderVersion));
 }
 
 void deepcopy_VkPhysicalDeviceVideoFormatInfoKHR(Allocator* alloc, VkStructureType rootType,
@@ -5710,12 +7157,6 @@ void deepcopy_VkPhysicalDeviceVideoFormatInfoKHR(Allocator* alloc, VkStructureTy
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pVideoProfiles = nullptr;
-    if (from->pVideoProfiles) {
-        to->pVideoProfiles = (VkVideoProfilesKHR*)alloc->alloc(sizeof(const VkVideoProfilesKHR));
-        deepcopy_VkVideoProfilesKHR(alloc, rootType, from->pVideoProfiles,
-                                    (VkVideoProfilesKHR*)(to->pVideoProfiles));
-    }
 }
 
 void deepcopy_VkVideoFormatPropertiesKHR(Allocator* alloc, VkStructureType rootType,
@@ -5738,11 +7179,13 @@ void deepcopy_VkVideoFormatPropertiesKHR(Allocator* alloc, VkStructureType rootT
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
+    deepcopy_VkComponentMapping(alloc, rootType, &from->componentMapping,
+                                (VkComponentMapping*)(&to->componentMapping));
 }
 
-void deepcopy_VkVideoPictureResourceKHR(Allocator* alloc, VkStructureType rootType,
-                                        const VkVideoPictureResourceKHR* from,
-                                        VkVideoPictureResourceKHR* to) {
+void deepcopy_VkVideoPictureResourceInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                            const VkVideoPictureResourceInfoKHR* from,
+                                            VkVideoPictureResourceInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -5764,9 +7207,9 @@ void deepcopy_VkVideoPictureResourceKHR(Allocator* alloc, VkStructureType rootTy
     deepcopy_VkExtent2D(alloc, rootType, &from->codedExtent, (VkExtent2D*)(&to->codedExtent));
 }
 
-void deepcopy_VkVideoReferenceSlotKHR(Allocator* alloc, VkStructureType rootType,
-                                      const VkVideoReferenceSlotKHR* from,
-                                      VkVideoReferenceSlotKHR* to) {
+void deepcopy_VkVideoReferenceSlotInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                          const VkVideoReferenceSlotInfoKHR* from,
+                                          VkVideoReferenceSlotInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -5786,16 +7229,17 @@ void deepcopy_VkVideoReferenceSlotKHR(Allocator* alloc, VkStructureType rootType
     }
     to->pPictureResource = nullptr;
     if (from->pPictureResource) {
-        to->pPictureResource =
-            (VkVideoPictureResourceKHR*)alloc->alloc(sizeof(const VkVideoPictureResourceKHR));
-        deepcopy_VkVideoPictureResourceKHR(alloc, rootType, from->pPictureResource,
-                                           (VkVideoPictureResourceKHR*)(to->pPictureResource));
+        to->pPictureResource = (VkVideoPictureResourceInfoKHR*)alloc->alloc(
+            sizeof(const VkVideoPictureResourceInfoKHR));
+        deepcopy_VkVideoPictureResourceInfoKHR(
+            alloc, rootType, from->pPictureResource,
+            (VkVideoPictureResourceInfoKHR*)(to->pPictureResource));
     }
 }
 
-void deepcopy_VkVideoGetMemoryPropertiesKHR(Allocator* alloc, VkStructureType rootType,
-                                            const VkVideoGetMemoryPropertiesKHR* from,
-                                            VkVideoGetMemoryPropertiesKHR* to) {
+void deepcopy_VkVideoSessionMemoryRequirementsKHR(Allocator* alloc, VkStructureType rootType,
+                                                  const VkVideoSessionMemoryRequirementsKHR* from,
+                                                  VkVideoSessionMemoryRequirementsKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -5813,17 +7257,13 @@ void deepcopy_VkVideoGetMemoryPropertiesKHR(Allocator* alloc, VkStructureType ro
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pMemoryRequirements = nullptr;
-    if (from->pMemoryRequirements) {
-        to->pMemoryRequirements =
-            (VkMemoryRequirements2*)alloc->alloc(sizeof(VkMemoryRequirements2));
-        deepcopy_VkMemoryRequirements2(alloc, rootType, from->pMemoryRequirements,
-                                       (VkMemoryRequirements2*)(to->pMemoryRequirements));
-    }
+    deepcopy_VkMemoryRequirements(alloc, rootType, &from->memoryRequirements,
+                                  (VkMemoryRequirements*)(&to->memoryRequirements));
 }
 
-void deepcopy_VkVideoBindMemoryKHR(Allocator* alloc, VkStructureType rootType,
-                                   const VkVideoBindMemoryKHR* from, VkVideoBindMemoryKHR* to) {
+void deepcopy_VkBindVideoSessionMemoryInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkBindVideoSessionMemoryInfoKHR* from,
+                                              VkBindVideoSessionMemoryInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -5865,11 +7305,19 @@ void deepcopy_VkVideoSessionCreateInfoKHR(Allocator* alloc, VkStructureType root
     }
     to->pVideoProfile = nullptr;
     if (from->pVideoProfile) {
-        to->pVideoProfile = (VkVideoProfileKHR*)alloc->alloc(sizeof(const VkVideoProfileKHR));
-        deepcopy_VkVideoProfileKHR(alloc, rootType, from->pVideoProfile,
-                                   (VkVideoProfileKHR*)(to->pVideoProfile));
+        to->pVideoProfile =
+            (VkVideoProfileInfoKHR*)alloc->alloc(sizeof(const VkVideoProfileInfoKHR));
+        deepcopy_VkVideoProfileInfoKHR(alloc, rootType, from->pVideoProfile,
+                                       (VkVideoProfileInfoKHR*)(to->pVideoProfile));
     }
     deepcopy_VkExtent2D(alloc, rootType, &from->maxCodedExtent, (VkExtent2D*)(&to->maxCodedExtent));
+    to->pStdHeaderVersion = nullptr;
+    if (from->pStdHeaderVersion) {
+        to->pStdHeaderVersion =
+            (VkExtensionProperties*)alloc->alloc(sizeof(const VkExtensionProperties));
+        deepcopy_VkExtensionProperties(alloc, rootType, from->pStdHeaderVersion,
+                                       (VkExtensionProperties*)(to->pStdHeaderVersion));
+    }
 }
 
 void deepcopy_VkVideoSessionParametersCreateInfoKHR(
@@ -5939,13 +7387,13 @@ void deepcopy_VkVideoBeginCodingInfoKHR(Allocator* alloc, VkStructureType rootTy
     if (from) {
         to->pReferenceSlots = nullptr;
         if (from->pReferenceSlots) {
-            to->pReferenceSlots = (VkVideoReferenceSlotKHR*)alloc->alloc(
-                from->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
+            to->pReferenceSlots = (VkVideoReferenceSlotInfoKHR*)alloc->alloc(
+                from->referenceSlotCount * sizeof(const VkVideoReferenceSlotInfoKHR));
             to->referenceSlotCount = from->referenceSlotCount;
             for (uint32_t i = 0; i < (uint32_t)from->referenceSlotCount; ++i) {
-                deepcopy_VkVideoReferenceSlotKHR(
+                deepcopy_VkVideoReferenceSlotInfoKHR(
                     alloc, rootType, from->pReferenceSlots + i,
-                    (VkVideoReferenceSlotKHR*)(to->pReferenceSlots + i));
+                    (VkVideoReferenceSlotInfoKHR*)(to->pReferenceSlots + i));
             }
         }
     }
@@ -5997,6 +7445,50 @@ void deepcopy_VkVideoCodingControlInfoKHR(Allocator* alloc, VkStructureType root
 
 #endif
 #ifdef VK_KHR_video_decode_queue
+void deepcopy_VkVideoDecodeCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+                                           const VkVideoDecodeCapabilitiesKHR* from,
+                                           VkVideoDecodeCapabilitiesKHR* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkVideoDecodeUsageInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                        const VkVideoDecodeUsageInfoKHR* from,
+                                        VkVideoDecodeUsageInfoKHR* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
 void deepcopy_VkVideoDecodeInfoKHR(Allocator* alloc, VkStructureType rootType,
                                    const VkVideoDecodeInfoKHR* from, VkVideoDecodeInfoKHR* to) {
     (void)alloc;
@@ -6016,37 +7508,37 @@ void deepcopy_VkVideoDecodeInfoKHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkOffset2D(alloc, rootType, &from->codedOffset, (VkOffset2D*)(&to->codedOffset));
-    deepcopy_VkExtent2D(alloc, rootType, &from->codedExtent, (VkExtent2D*)(&to->codedExtent));
-    deepcopy_VkVideoPictureResourceKHR(alloc, rootType, &from->dstPictureResource,
-                                       (VkVideoPictureResourceKHR*)(&to->dstPictureResource));
+    deepcopy_VkVideoPictureResourceInfoKHR(
+        alloc, rootType, &from->dstPictureResource,
+        (VkVideoPictureResourceInfoKHR*)(&to->dstPictureResource));
     to->pSetupReferenceSlot = nullptr;
     if (from->pSetupReferenceSlot) {
         to->pSetupReferenceSlot =
-            (VkVideoReferenceSlotKHR*)alloc->alloc(sizeof(const VkVideoReferenceSlotKHR));
-        deepcopy_VkVideoReferenceSlotKHR(alloc, rootType, from->pSetupReferenceSlot,
-                                         (VkVideoReferenceSlotKHR*)(to->pSetupReferenceSlot));
+            (VkVideoReferenceSlotInfoKHR*)alloc->alloc(sizeof(const VkVideoReferenceSlotInfoKHR));
+        deepcopy_VkVideoReferenceSlotInfoKHR(
+            alloc, rootType, from->pSetupReferenceSlot,
+            (VkVideoReferenceSlotInfoKHR*)(to->pSetupReferenceSlot));
     }
     if (from) {
         to->pReferenceSlots = nullptr;
         if (from->pReferenceSlots) {
-            to->pReferenceSlots = (VkVideoReferenceSlotKHR*)alloc->alloc(
-                from->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
+            to->pReferenceSlots = (VkVideoReferenceSlotInfoKHR*)alloc->alloc(
+                from->referenceSlotCount * sizeof(const VkVideoReferenceSlotInfoKHR));
             to->referenceSlotCount = from->referenceSlotCount;
             for (uint32_t i = 0; i < (uint32_t)from->referenceSlotCount; ++i) {
-                deepcopy_VkVideoReferenceSlotKHR(
+                deepcopy_VkVideoReferenceSlotInfoKHR(
                     alloc, rootType, from->pReferenceSlots + i,
-                    (VkVideoReferenceSlotKHR*)(to->pReferenceSlots + i));
+                    (VkVideoReferenceSlotInfoKHR*)(to->pReferenceSlots + i));
             }
         }
     }
 }
 
 #endif
-#ifdef VK_KHR_dynamic_rendering
-void deepcopy_VkRenderingAttachmentInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                           const VkRenderingAttachmentInfoKHR* from,
-                                           VkRenderingAttachmentInfoKHR* to) {
+#ifdef VK_KHR_video_decode_h264
+void deepcopy_VkVideoDecodeH264ProfileInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoDecodeH264ProfileInfoKHR* from,
+                                              VkVideoDecodeH264ProfileInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -6064,11 +7556,11 @@ void deepcopy_VkRenderingAttachmentInfoKHR(Allocator* alloc, VkStructureType roo
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkClearValue(alloc, rootType, &from->clearValue, (VkClearValue*)(&to->clearValue));
 }
 
-void deepcopy_VkRenderingInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                 const VkRenderingInfoKHR* from, VkRenderingInfoKHR* to) {
+void deepcopy_VkVideoDecodeH264CapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+                                               const VkVideoDecodeH264CapabilitiesKHR* from,
+                                               VkVideoDecodeH264CapabilitiesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -6086,41 +7578,47 @@ void deepcopy_VkRenderingInfoKHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkRect2D(alloc, rootType, &from->renderArea, (VkRect2D*)(&to->renderArea));
-    if (from) {
-        to->pColorAttachments = nullptr;
-        if (from->pColorAttachments) {
-            to->pColorAttachments = (VkRenderingAttachmentInfoKHR*)alloc->alloc(
-                from->colorAttachmentCount * sizeof(const VkRenderingAttachmentInfoKHR));
-            to->colorAttachmentCount = from->colorAttachmentCount;
-            for (uint32_t i = 0; i < (uint32_t)from->colorAttachmentCount; ++i) {
-                deepcopy_VkRenderingAttachmentInfoKHR(
-                    alloc, rootType, from->pColorAttachments + i,
-                    (VkRenderingAttachmentInfoKHR*)(to->pColorAttachments + i));
-            }
-        }
+    deepcopy_VkOffset2D(alloc, rootType, &from->fieldOffsetGranularity,
+                        (VkOffset2D*)(&to->fieldOffsetGranularity));
+}
+
+void deepcopy_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkVideoDecodeH264SessionParametersAddInfoKHR* from,
+    VkVideoDecodeH264SessionParametersAddInfoKHR* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
     }
-    to->pDepthAttachment = nullptr;
-    if (from->pDepthAttachment) {
-        to->pDepthAttachment =
-            (VkRenderingAttachmentInfoKHR*)alloc->alloc(sizeof(const VkRenderingAttachmentInfoKHR));
-        deepcopy_VkRenderingAttachmentInfoKHR(
-            alloc, rootType, from->pDepthAttachment,
-            (VkRenderingAttachmentInfoKHR*)(to->pDepthAttachment));
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
     }
-    to->pStencilAttachment = nullptr;
-    if (from->pStencilAttachment) {
-        to->pStencilAttachment =
-            (VkRenderingAttachmentInfoKHR*)alloc->alloc(sizeof(const VkRenderingAttachmentInfoKHR));
-        deepcopy_VkRenderingAttachmentInfoKHR(
-            alloc, rootType, from->pStencilAttachment,
-            (VkRenderingAttachmentInfoKHR*)(to->pStencilAttachment));
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pStdSPSs = nullptr;
+    if (from->pStdSPSs) {
+        to->pStdSPSs = (StdVideoH264SequenceParameterSet*)alloc->dupArray(
+            from->pStdSPSs, from->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
+    }
+    to->pStdPPSs = nullptr;
+    if (from->pStdPPSs) {
+        to->pStdPPSs = (StdVideoH264PictureParameterSet*)alloc->dupArray(
+            from->pStdPPSs, from->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
     }
 }
 
-void deepcopy_VkPipelineRenderingCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                               const VkPipelineRenderingCreateInfoKHR* from,
-                                               VkPipelineRenderingCreateInfoKHR* to) {
+void deepcopy_VkVideoDecodeH264SessionParametersCreateInfoKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkVideoDecodeH264SessionParametersCreateInfoKHR* from,
+    VkVideoDecodeH264SessionParametersCreateInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -6138,17 +7636,19 @@ void deepcopy_VkPipelineRenderingCreateInfoKHR(Allocator* alloc, VkStructureType
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pColorAttachmentFormats = nullptr;
-    if (from->pColorAttachmentFormats) {
-        to->pColorAttachmentFormats = (VkFormat*)alloc->dupArray(
-            from->pColorAttachmentFormats, from->colorAttachmentCount * sizeof(const VkFormat));
+    to->pParametersAddInfo = nullptr;
+    if (from->pParametersAddInfo) {
+        to->pParametersAddInfo = (VkVideoDecodeH264SessionParametersAddInfoKHR*)alloc->alloc(
+            sizeof(const VkVideoDecodeH264SessionParametersAddInfoKHR));
+        deepcopy_VkVideoDecodeH264SessionParametersAddInfoKHR(
+            alloc, rootType, from->pParametersAddInfo,
+            (VkVideoDecodeH264SessionParametersAddInfoKHR*)(to->pParametersAddInfo));
     }
 }
 
-void deepcopy_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceDynamicRenderingFeaturesKHR* from,
-    VkPhysicalDeviceDynamicRenderingFeaturesKHR* to) {
+void deepcopy_VkVideoDecodeH264PictureInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoDecodeH264PictureInfoKHR* from,
+                                              VkVideoDecodeH264PictureInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -6166,12 +7666,21 @@ void deepcopy_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
+    to->pStdPictureInfo = nullptr;
+    if (from->pStdPictureInfo) {
+        to->pStdPictureInfo = (StdVideoDecodeH264PictureInfo*)alloc->dupArray(
+            from->pStdPictureInfo, sizeof(const StdVideoDecodeH264PictureInfo));
+    }
+    to->pSliceOffsets = nullptr;
+    if (from->pSliceOffsets) {
+        to->pSliceOffsets = (uint32_t*)alloc->dupArray(from->pSliceOffsets,
+                                                       from->sliceCount * sizeof(const uint32_t));
+    }
 }
 
-void deepcopy_VkCommandBufferInheritanceRenderingInfoKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkCommandBufferInheritanceRenderingInfoKHR* from,
-    VkCommandBufferInheritanceRenderingInfoKHR* to) {
+void deepcopy_VkVideoDecodeH264DpbSlotInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoDecodeH264DpbSlotInfoKHR* from,
+                                              VkVideoDecodeH264DpbSlotInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -6189,13 +7698,15 @@ void deepcopy_VkCommandBufferInheritanceRenderingInfoKHR(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pColorAttachmentFormats = nullptr;
-    if (from->pColorAttachmentFormats) {
-        to->pColorAttachmentFormats = (VkFormat*)alloc->dupArray(
-            from->pColorAttachmentFormats, from->colorAttachmentCount * sizeof(const VkFormat));
+    to->pStdReferenceInfo = nullptr;
+    if (from->pStdReferenceInfo) {
+        to->pStdReferenceInfo = (StdVideoDecodeH264ReferenceInfo*)alloc->dupArray(
+            from->pStdReferenceInfo, sizeof(const StdVideoDecodeH264ReferenceInfo));
     }
 }
 
+#endif
+#ifdef VK_KHR_dynamic_rendering
 void deepcopy_VkRenderingFragmentShadingRateAttachmentInfoKHR(
     Allocator* alloc, VkStructureType rootType,
     const VkRenderingFragmentShadingRateAttachmentInfoKHR* from,
@@ -7389,23 +8900,10 @@ void deepcopy_VkPhysicalDeviceShaderClockFeaturesKHR(
 }
 
 #endif
-#ifdef VK_KHR_driver_properties
-#endif
-#ifdef VK_KHR_shader_float_controls
-#endif
-#ifdef VK_KHR_depth_stencil_resolve
-#endif
-#ifdef VK_KHR_swapchain_mutable_format
-#endif
-#ifdef VK_KHR_timeline_semaphore
-#endif
-#ifdef VK_KHR_vulkan_memory_model
-#endif
-#ifdef VK_KHR_shader_terminate_invocation
-void deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* from,
-    VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* to) {
+#ifdef VK_KHR_video_decode_h265
+void deepcopy_VkVideoDecodeH265ProfileInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoDecodeH265ProfileInfoKHR* from,
+                                              VkVideoDecodeH265ProfileInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7425,11 +8923,9 @@ void deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
     }
 }
 
-#endif
-#ifdef VK_KHR_fragment_shading_rate
-void deepcopy_VkFragmentShadingRateAttachmentInfoKHR(
-    Allocator* alloc, VkStructureType rootType, const VkFragmentShadingRateAttachmentInfoKHR* from,
-    VkFragmentShadingRateAttachmentInfoKHR* to) {
+void deepcopy_VkVideoDecodeH265CapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+                                               const VkVideoDecodeH265CapabilitiesKHR* from,
+                                               VkVideoDecodeH265CapabilitiesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7447,22 +8943,12 @@ void deepcopy_VkFragmentShadingRateAttachmentInfoKHR(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pFragmentShadingRateAttachment = nullptr;
-    if (from->pFragmentShadingRateAttachment) {
-        to->pFragmentShadingRateAttachment =
-            (VkAttachmentReference2*)alloc->alloc(sizeof(const VkAttachmentReference2));
-        deepcopy_VkAttachmentReference2(
-            alloc, rootType, from->pFragmentShadingRateAttachment,
-            (VkAttachmentReference2*)(to->pFragmentShadingRateAttachment));
-    }
-    deepcopy_VkExtent2D(alloc, rootType, &from->shadingRateAttachmentTexelSize,
-                        (VkExtent2D*)(&to->shadingRateAttachmentTexelSize));
 }
 
-void deepcopy_VkPipelineFragmentShadingRateStateCreateInfoKHR(
+void deepcopy_VkVideoDecodeH265SessionParametersAddInfoKHR(
     Allocator* alloc, VkStructureType rootType,
-    const VkPipelineFragmentShadingRateStateCreateInfoKHR* from,
-    VkPipelineFragmentShadingRateStateCreateInfoKHR* to) {
+    const VkVideoDecodeH265SessionParametersAddInfoKHR* from,
+    VkVideoDecodeH265SessionParametersAddInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7480,37 +8966,27 @@ void deepcopy_VkPipelineFragmentShadingRateStateCreateInfoKHR(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkExtent2D(alloc, rootType, &from->fragmentSize, (VkExtent2D*)(&to->fragmentSize));
-    memcpy(to->combinerOps, from->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
-}
-
-void deepcopy_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* from,
-    VkPhysicalDeviceFragmentShadingRateFeaturesKHR* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
+    to->pStdVPSs = nullptr;
+    if (from->pStdVPSs) {
+        to->pStdVPSs = (StdVideoH265VideoParameterSet*)alloc->dupArray(
+            from->pStdVPSs, from->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
     }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    to->pStdSPSs = nullptr;
+    if (from->pStdSPSs) {
+        to->pStdSPSs = (StdVideoH265SequenceParameterSet*)alloc->dupArray(
+            from->pStdSPSs, from->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
     }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    to->pStdPPSs = nullptr;
+    if (from->pStdPPSs) {
+        to->pStdPPSs = (StdVideoH265PictureParameterSet*)alloc->dupArray(
+            from->pStdPPSs, from->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
     }
 }
 
-void deepcopy_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
+void deepcopy_VkVideoDecodeH265SessionParametersCreateInfoKHR(
     Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* from,
-    VkPhysicalDeviceFragmentShadingRatePropertiesKHR* to) {
+    const VkVideoDecodeH265SessionParametersCreateInfoKHR* from,
+    VkVideoDecodeH265SessionParametersCreateInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7528,17 +9004,19 @@ void deepcopy_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkExtent2D(alloc, rootType, &from->minFragmentShadingRateAttachmentTexelSize,
-                        (VkExtent2D*)(&to->minFragmentShadingRateAttachmentTexelSize));
-    deepcopy_VkExtent2D(alloc, rootType, &from->maxFragmentShadingRateAttachmentTexelSize,
-                        (VkExtent2D*)(&to->maxFragmentShadingRateAttachmentTexelSize));
-    deepcopy_VkExtent2D(alloc, rootType, &from->maxFragmentSize,
-                        (VkExtent2D*)(&to->maxFragmentSize));
+    to->pParametersAddInfo = nullptr;
+    if (from->pParametersAddInfo) {
+        to->pParametersAddInfo = (VkVideoDecodeH265SessionParametersAddInfoKHR*)alloc->alloc(
+            sizeof(const VkVideoDecodeH265SessionParametersAddInfoKHR));
+        deepcopy_VkVideoDecodeH265SessionParametersAddInfoKHR(
+            alloc, rootType, from->pParametersAddInfo,
+            (VkVideoDecodeH265SessionParametersAddInfoKHR*)(to->pParametersAddInfo));
+    }
 }
 
-void deepcopy_VkPhysicalDeviceFragmentShadingRateKHR(
-    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceFragmentShadingRateKHR* from,
-    VkPhysicalDeviceFragmentShadingRateKHR* to) {
+void deepcopy_VkVideoDecodeH265PictureInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoDecodeH265PictureInfoKHR* from,
+                                              VkVideoDecodeH265PictureInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7556,42 +9034,21 @@ void deepcopy_VkPhysicalDeviceFragmentShadingRateKHR(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkExtent2D(alloc, rootType, &from->fragmentSize, (VkExtent2D*)(&to->fragmentSize));
-}
-
-#endif
-#ifdef VK_KHR_spirv_1_4
-#endif
-#ifdef VK_KHR_surface_protected_capabilities
-void deepcopy_VkSurfaceProtectedCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
-                                                const VkSurfaceProtectedCapabilitiesKHR* from,
-                                                VkSurfaceProtectedCapabilitiesKHR* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    to->pStdPictureInfo = nullptr;
+    if (from->pStdPictureInfo) {
+        to->pStdPictureInfo = (StdVideoDecodeH265PictureInfo*)alloc->dupArray(
+            from->pStdPictureInfo, sizeof(const StdVideoDecodeH265PictureInfo));
     }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    to->pSliceSegmentOffsets = nullptr;
+    if (from->pSliceSegmentOffsets) {
+        to->pSliceSegmentOffsets = (uint32_t*)alloc->dupArray(
+            from->pSliceSegmentOffsets, from->sliceSegmentCount * sizeof(const uint32_t));
     }
 }
 
-#endif
-#ifdef VK_KHR_separate_depth_stencil_layouts
-#endif
-#ifdef VK_KHR_present_wait
-void deepcopy_VkPhysicalDevicePresentWaitFeaturesKHR(
-    Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePresentWaitFeaturesKHR* from,
-    VkPhysicalDevicePresentWaitFeaturesKHR* to) {
+void deepcopy_VkVideoDecodeH265DpbSlotInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoDecodeH265DpbSlotInfoKHR* from,
+                                              VkVideoDecodeH265DpbSlotInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7609,20 +9066,19 @@ void deepcopy_VkPhysicalDevicePresentWaitFeaturesKHR(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
+    to->pStdReferenceInfo = nullptr;
+    if (from->pStdReferenceInfo) {
+        to->pStdReferenceInfo = (StdVideoDecodeH265ReferenceInfo*)alloc->dupArray(
+            from->pStdReferenceInfo, sizeof(const StdVideoDecodeH265ReferenceInfo));
+    }
 }
 
 #endif
-#ifdef VK_KHR_uniform_buffer_standard_layout
-#endif
-#ifdef VK_KHR_buffer_device_address
-#endif
-#ifdef VK_KHR_deferred_host_operations
-#endif
-#ifdef VK_KHR_pipeline_executable_properties
-void deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+#ifdef VK_KHR_global_priority
+void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoKHR(
     Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* from,
-    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* to) {
+    const VkDeviceQueueGlobalPriorityCreateInfoKHR* from,
+    VkDeviceQueueGlobalPriorityCreateInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7642,8 +9098,10 @@ void deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
     }
 }
 
-void deepcopy_VkPipelineInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                const VkPipelineInfoKHR* from, VkPipelineInfoKHR* to) {
+void deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* from,
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7663,9 +9121,10 @@ void deepcopy_VkPipelineInfoKHR(Allocator* alloc, VkStructureType rootType,
     }
 }
 
-void deepcopy_VkPipelineExecutablePropertiesKHR(Allocator* alloc, VkStructureType rootType,
-                                                const VkPipelineExecutablePropertiesKHR* from,
-                                                VkPipelineExecutablePropertiesKHR* to) {
+void deepcopy_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkQueueFamilyGlobalPriorityPropertiesKHR* from,
+    VkQueueFamilyGlobalPriorityPropertiesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7683,13 +9142,29 @@ void deepcopy_VkPipelineExecutablePropertiesKHR(Allocator* alloc, VkStructureTyp
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    memcpy(to->name, from->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    memcpy(to->priorities, from->priorities,
+           VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
 }
 
-void deepcopy_VkPipelineExecutableInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                          const VkPipelineExecutableInfoKHR* from,
-                                          VkPipelineExecutableInfoKHR* to) {
+#endif
+#ifdef VK_KHR_driver_properties
+#endif
+#ifdef VK_KHR_shader_float_controls
+#endif
+#ifdef VK_KHR_depth_stencil_resolve
+#endif
+#ifdef VK_KHR_swapchain_mutable_format
+#endif
+#ifdef VK_KHR_timeline_semaphore
+#endif
+#ifdef VK_KHR_vulkan_memory_model
+#endif
+#ifdef VK_KHR_shader_terminate_invocation
+#endif
+#ifdef VK_KHR_fragment_shading_rate
+void deepcopy_VkFragmentShadingRateAttachmentInfoKHR(
+    Allocator* alloc, VkStructureType rootType, const VkFragmentShadingRateAttachmentInfoKHR* from,
+    VkFragmentShadingRateAttachmentInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7707,19 +9182,22 @@ void deepcopy_VkPipelineExecutableInfoKHR(Allocator* alloc, VkStructureType root
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
+    to->pFragmentShadingRateAttachment = nullptr;
+    if (from->pFragmentShadingRateAttachment) {
+        to->pFragmentShadingRateAttachment =
+            (VkAttachmentReference2*)alloc->alloc(sizeof(const VkAttachmentReference2));
+        deepcopy_VkAttachmentReference2(
+            alloc, rootType, from->pFragmentShadingRateAttachment,
+            (VkAttachmentReference2*)(to->pFragmentShadingRateAttachment));
+    }
+    deepcopy_VkExtent2D(alloc, rootType, &from->shadingRateAttachmentTexelSize,
+                        (VkExtent2D*)(&to->shadingRateAttachmentTexelSize));
 }
 
-void deepcopy_VkPipelineExecutableStatisticValueKHR(
-    Allocator* alloc, VkStructureType rootType, const VkPipelineExecutableStatisticValueKHR* from,
-    VkPipelineExecutableStatisticValueKHR* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-}
-
-void deepcopy_VkPipelineExecutableStatisticKHR(Allocator* alloc, VkStructureType rootType,
-                                               const VkPipelineExecutableStatisticKHR* from,
-                                               VkPipelineExecutableStatisticKHR* to) {
+void deepcopy_VkPipelineFragmentShadingRateStateCreateInfoKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPipelineFragmentShadingRateStateCreateInfoKHR* from,
+    VkPipelineFragmentShadingRateStateCreateInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7737,16 +9215,14 @@ void deepcopy_VkPipelineExecutableStatisticKHR(Allocator* alloc, VkStructureType
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    memcpy(to->name, from->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    deepcopy_VkPipelineExecutableStatisticValueKHR(
-        alloc, rootType, &from->value, (VkPipelineExecutableStatisticValueKHR*)(&to->value));
+    deepcopy_VkExtent2D(alloc, rootType, &from->fragmentSize, (VkExtent2D*)(&to->fragmentSize));
+    memcpy(to->combinerOps, from->combinerOps, 2 * sizeof(VkFragmentShadingRateCombinerOpKHR));
 }
 
-void deepcopy_VkPipelineExecutableInternalRepresentationKHR(
+void deepcopy_VkPhysicalDeviceFragmentShadingRateFeaturesKHR(
     Allocator* alloc, VkStructureType rootType,
-    const VkPipelineExecutableInternalRepresentationKHR* from,
-    VkPipelineExecutableInternalRepresentationKHR* to) {
+    const VkPhysicalDeviceFragmentShadingRateFeaturesKHR* from,
+    VkPhysicalDeviceFragmentShadingRateFeaturesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7764,20 +9240,12 @@ void deepcopy_VkPipelineExecutableInternalRepresentationKHR(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    memcpy(to->name, from->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    to->pData = nullptr;
-    if (from->pData) {
-        to->pData = (void*)alloc->dupArray(from->pData, from->dataSize * sizeof(uint8_t));
-    }
 }
 
-#endif
-#ifdef VK_KHR_shader_integer_dot_product
-void deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
+void deepcopy_VkPhysicalDeviceFragmentShadingRatePropertiesKHR(
     Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* from,
-    VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* to) {
+    const VkPhysicalDeviceFragmentShadingRatePropertiesKHR* from,
+    VkPhysicalDeviceFragmentShadingRatePropertiesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7795,12 +9263,17 @@ void deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
+    deepcopy_VkExtent2D(alloc, rootType, &from->minFragmentShadingRateAttachmentTexelSize,
+                        (VkExtent2D*)(&to->minFragmentShadingRateAttachmentTexelSize));
+    deepcopy_VkExtent2D(alloc, rootType, &from->maxFragmentShadingRateAttachmentTexelSize,
+                        (VkExtent2D*)(&to->maxFragmentShadingRateAttachmentTexelSize));
+    deepcopy_VkExtent2D(alloc, rootType, &from->maxFragmentSize,
+                        (VkExtent2D*)(&to->maxFragmentSize));
 }
 
-void deepcopy_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* from,
-    VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* to) {
+void deepcopy_VkPhysicalDeviceFragmentShadingRateKHR(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceFragmentShadingRateKHR* from,
+    VkPhysicalDeviceFragmentShadingRateKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7818,13 +9291,16 @@ void deepcopy_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
+    deepcopy_VkExtent2D(alloc, rootType, &from->fragmentSize, (VkExtent2D*)(&to->fragmentSize));
 }
 
 #endif
-#ifdef VK_KHR_pipeline_library
-void deepcopy_VkPipelineLibraryCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                             const VkPipelineLibraryCreateInfoKHR* from,
-                                             VkPipelineLibraryCreateInfoKHR* to) {
+#ifdef VK_KHR_spirv_1_4
+#endif
+#ifdef VK_KHR_surface_protected_capabilities
+void deepcopy_VkSurfaceProtectedCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+                                                const VkSurfaceProtectedCapabilitiesKHR* from,
+                                                VkSurfaceProtectedCapabilitiesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7842,19 +9318,15 @@ void deepcopy_VkPipelineLibraryCreateInfoKHR(Allocator* alloc, VkStructureType r
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pLibraries = nullptr;
-    if (from->pLibraries) {
-        to->pLibraries = (VkPipeline*)alloc->dupArray(
-            from->pLibraries, from->libraryCount * sizeof(const VkPipeline));
-    }
 }
 
 #endif
-#ifdef VK_KHR_shader_non_semantic_info
+#ifdef VK_KHR_separate_depth_stencil_layouts
 #endif
-#ifdef VK_KHR_present_id
-void deepcopy_VkPresentIdKHR(Allocator* alloc, VkStructureType rootType, const VkPresentIdKHR* from,
-                             VkPresentIdKHR* to) {
+#ifdef VK_KHR_present_wait
+void deepcopy_VkPhysicalDevicePresentWaitFeaturesKHR(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePresentWaitFeaturesKHR* from,
+    VkPhysicalDevicePresentWaitFeaturesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7872,16 +9344,20 @@ void deepcopy_VkPresentIdKHR(Allocator* alloc, VkStructureType rootType, const V
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pPresentIds = nullptr;
-    if (from->pPresentIds) {
-        to->pPresentIds = (uint64_t*)alloc->dupArray(from->pPresentIds,
-                                                     from->swapchainCount * sizeof(const uint64_t));
-    }
 }
 
-void deepcopy_VkPhysicalDevicePresentIdFeaturesKHR(Allocator* alloc, VkStructureType rootType,
-                                                   const VkPhysicalDevicePresentIdFeaturesKHR* from,
-                                                   VkPhysicalDevicePresentIdFeaturesKHR* to) {
+#endif
+#ifdef VK_KHR_uniform_buffer_standard_layout
+#endif
+#ifdef VK_KHR_buffer_device_address
+#endif
+#ifdef VK_KHR_deferred_host_operations
+#endif
+#ifdef VK_KHR_pipeline_executable_properties
+void deepcopy_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* from,
+    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7901,10 +9377,8 @@ void deepcopy_VkPhysicalDevicePresentIdFeaturesKHR(Allocator* alloc, VkStructure
     }
 }
 
-#endif
-#ifdef VK_KHR_video_encode_queue
-void deepcopy_VkVideoEncodeInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                   const VkVideoEncodeInfoKHR* from, VkVideoEncodeInfoKHR* to) {
+void deepcopy_VkPipelineInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                const VkPipelineInfoKHR* from, VkPipelineInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7922,34 +9396,11 @@ void deepcopy_VkVideoEncodeInfoKHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkExtent2D(alloc, rootType, &from->codedExtent, (VkExtent2D*)(&to->codedExtent));
-    deepcopy_VkVideoPictureResourceKHR(alloc, rootType, &from->srcPictureResource,
-                                       (VkVideoPictureResourceKHR*)(&to->srcPictureResource));
-    to->pSetupReferenceSlot = nullptr;
-    if (from->pSetupReferenceSlot) {
-        to->pSetupReferenceSlot =
-            (VkVideoReferenceSlotKHR*)alloc->alloc(sizeof(const VkVideoReferenceSlotKHR));
-        deepcopy_VkVideoReferenceSlotKHR(alloc, rootType, from->pSetupReferenceSlot,
-                                         (VkVideoReferenceSlotKHR*)(to->pSetupReferenceSlot));
-    }
-    if (from) {
-        to->pReferenceSlots = nullptr;
-        if (from->pReferenceSlots) {
-            to->pReferenceSlots = (VkVideoReferenceSlotKHR*)alloc->alloc(
-                from->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
-            to->referenceSlotCount = from->referenceSlotCount;
-            for (uint32_t i = 0; i < (uint32_t)from->referenceSlotCount; ++i) {
-                deepcopy_VkVideoReferenceSlotKHR(
-                    alloc, rootType, from->pReferenceSlots + i,
-                    (VkVideoReferenceSlotKHR*)(to->pReferenceSlots + i));
-            }
-        }
-    }
 }
 
-void deepcopy_VkVideoEncodeRateControlInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                              const VkVideoEncodeRateControlInfoKHR* from,
-                                              VkVideoEncodeRateControlInfoKHR* to) {
+void deepcopy_VkPipelineExecutablePropertiesKHR(Allocator* alloc, VkStructureType rootType,
+                                                const VkPipelineExecutablePropertiesKHR* from,
+                                                VkPipelineExecutablePropertiesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7967,12 +9418,13 @@ void deepcopy_VkVideoEncodeRateControlInfoKHR(Allocator* alloc, VkStructureType
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
+    memcpy(to->name, from->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
 }
 
-#endif
-#ifdef VK_KHR_synchronization2
-void deepcopy_VkMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootType,
-                                  const VkMemoryBarrier2KHR* from, VkMemoryBarrier2KHR* to) {
+void deepcopy_VkPipelineExecutableInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                          const VkPipelineExecutableInfoKHR* from,
+                                          VkPipelineExecutableInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -7992,31 +9444,17 @@ void deepcopy_VkMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootType,
     }
 }
 
-void deepcopy_VkBufferMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootType,
-                                        const VkBufferMemoryBarrier2KHR* from,
-                                        VkBufferMemoryBarrier2KHR* to) {
+void deepcopy_VkPipelineExecutableStatisticValueKHR(
+    Allocator* alloc, VkStructureType rootType, const VkPipelineExecutableStatisticValueKHR* from,
+    VkPipelineExecutableStatisticValueKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
 }
 
-void deepcopy_VkImageMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootType,
-                                       const VkImageMemoryBarrier2KHR* from,
-                                       VkImageMemoryBarrier2KHR* to) {
+void deepcopy_VkPipelineExecutableStatisticKHR(Allocator* alloc, VkStructureType rootType,
+                                               const VkPipelineExecutableStatisticKHR* from,
+                                               VkPipelineExecutableStatisticKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8034,12 +9472,16 @@ void deepcopy_VkImageMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootTyp
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkImageSubresourceRange(alloc, rootType, &from->subresourceRange,
-                                     (VkImageSubresourceRange*)(&to->subresourceRange));
+    memcpy(to->name, from->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    deepcopy_VkPipelineExecutableStatisticValueKHR(
+        alloc, rootType, &from->value, (VkPipelineExecutableStatisticValueKHR*)(&to->value));
 }
 
-void deepcopy_VkDependencyInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                  const VkDependencyInfoKHR* from, VkDependencyInfoKHR* to) {
+void deepcopy_VkPipelineExecutableInternalRepresentationKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPipelineExecutableInternalRepresentationKHR* from,
+    VkPipelineExecutableInternalRepresentationKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8057,49 +9499,18 @@ void deepcopy_VkDependencyInfoKHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    if (from) {
-        to->pMemoryBarriers = nullptr;
-        if (from->pMemoryBarriers) {
-            to->pMemoryBarriers = (VkMemoryBarrier2KHR*)alloc->alloc(
-                from->memoryBarrierCount * sizeof(const VkMemoryBarrier2KHR));
-            to->memoryBarrierCount = from->memoryBarrierCount;
-            for (uint32_t i = 0; i < (uint32_t)from->memoryBarrierCount; ++i) {
-                deepcopy_VkMemoryBarrier2KHR(alloc, rootType, from->pMemoryBarriers + i,
-                                             (VkMemoryBarrier2KHR*)(to->pMemoryBarriers + i));
-            }
-        }
-    }
-    if (from) {
-        to->pBufferMemoryBarriers = nullptr;
-        if (from->pBufferMemoryBarriers) {
-            to->pBufferMemoryBarriers = (VkBufferMemoryBarrier2KHR*)alloc->alloc(
-                from->bufferMemoryBarrierCount * sizeof(const VkBufferMemoryBarrier2KHR));
-            to->bufferMemoryBarrierCount = from->bufferMemoryBarrierCount;
-            for (uint32_t i = 0; i < (uint32_t)from->bufferMemoryBarrierCount; ++i) {
-                deepcopy_VkBufferMemoryBarrier2KHR(
-                    alloc, rootType, from->pBufferMemoryBarriers + i,
-                    (VkBufferMemoryBarrier2KHR*)(to->pBufferMemoryBarriers + i));
-            }
-        }
-    }
-    if (from) {
-        to->pImageMemoryBarriers = nullptr;
-        if (from->pImageMemoryBarriers) {
-            to->pImageMemoryBarriers = (VkImageMemoryBarrier2KHR*)alloc->alloc(
-                from->imageMemoryBarrierCount * sizeof(const VkImageMemoryBarrier2KHR));
-            to->imageMemoryBarrierCount = from->imageMemoryBarrierCount;
-            for (uint32_t i = 0; i < (uint32_t)from->imageMemoryBarrierCount; ++i) {
-                deepcopy_VkImageMemoryBarrier2KHR(
-                    alloc, rootType, from->pImageMemoryBarriers + i,
-                    (VkImageMemoryBarrier2KHR*)(to->pImageMemoryBarriers + i));
-            }
-        }
+    memcpy(to->name, from->name, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    to->pData = nullptr;
+    if (from->pData) {
+        to->pData = (void*)alloc->dupArray(from->pData, from->dataSize * sizeof(uint8_t));
     }
 }
 
-void deepcopy_VkSemaphoreSubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                       const VkSemaphoreSubmitInfoKHR* from,
-                                       VkSemaphoreSubmitInfoKHR* to) {
+#endif
+#ifdef VK_KHR_map_memory2
+void deepcopy_VkMemoryMapInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                 const VkMemoryMapInfoKHR* from, VkMemoryMapInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8119,9 +9530,8 @@ void deepcopy_VkSemaphoreSubmitInfoKHR(Allocator* alloc, VkStructureType rootTyp
     }
 }
 
-void deepcopy_VkCommandBufferSubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                           const VkCommandBufferSubmitInfoKHR* from,
-                                           VkCommandBufferSubmitInfoKHR* to) {
+void deepcopy_VkMemoryUnmapInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                   const VkMemoryUnmapInfoKHR* from, VkMemoryUnmapInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8141,8 +9551,13 @@ void deepcopy_VkCommandBufferSubmitInfoKHR(Allocator* alloc, VkStructureType roo
     }
 }
 
-void deepcopy_VkSubmitInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                               const VkSubmitInfo2KHR* from, VkSubmitInfo2KHR* to) {
+#endif
+#ifdef VK_KHR_shader_integer_dot_product
+#endif
+#ifdef VK_KHR_pipeline_library
+void deepcopy_VkPipelineLibraryCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                             const VkPipelineLibraryCreateInfoKHR* from,
+                                             VkPipelineLibraryCreateInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8160,51 +9575,19 @@ void deepcopy_VkSubmitInfo2KHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    if (from) {
-        to->pWaitSemaphoreInfos = nullptr;
-        if (from->pWaitSemaphoreInfos) {
-            to->pWaitSemaphoreInfos = (VkSemaphoreSubmitInfoKHR*)alloc->alloc(
-                from->waitSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfoKHR));
-            to->waitSemaphoreInfoCount = from->waitSemaphoreInfoCount;
-            for (uint32_t i = 0; i < (uint32_t)from->waitSemaphoreInfoCount; ++i) {
-                deepcopy_VkSemaphoreSubmitInfoKHR(
-                    alloc, rootType, from->pWaitSemaphoreInfos + i,
-                    (VkSemaphoreSubmitInfoKHR*)(to->pWaitSemaphoreInfos + i));
-            }
-        }
-    }
-    if (from) {
-        to->pCommandBufferInfos = nullptr;
-        if (from->pCommandBufferInfos) {
-            to->pCommandBufferInfos = (VkCommandBufferSubmitInfoKHR*)alloc->alloc(
-                from->commandBufferInfoCount * sizeof(const VkCommandBufferSubmitInfoKHR));
-            to->commandBufferInfoCount = from->commandBufferInfoCount;
-            for (uint32_t i = 0; i < (uint32_t)from->commandBufferInfoCount; ++i) {
-                deepcopy_VkCommandBufferSubmitInfoKHR(
-                    alloc, rootType, from->pCommandBufferInfos + i,
-                    (VkCommandBufferSubmitInfoKHR*)(to->pCommandBufferInfos + i));
-            }
-        }
-    }
-    if (from) {
-        to->pSignalSemaphoreInfos = nullptr;
-        if (from->pSignalSemaphoreInfos) {
-            to->pSignalSemaphoreInfos = (VkSemaphoreSubmitInfoKHR*)alloc->alloc(
-                from->signalSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfoKHR));
-            to->signalSemaphoreInfoCount = from->signalSemaphoreInfoCount;
-            for (uint32_t i = 0; i < (uint32_t)from->signalSemaphoreInfoCount; ++i) {
-                deepcopy_VkSemaphoreSubmitInfoKHR(
-                    alloc, rootType, from->pSignalSemaphoreInfos + i,
-                    (VkSemaphoreSubmitInfoKHR*)(to->pSignalSemaphoreInfos + i));
-            }
-        }
+    to->pLibraries = nullptr;
+    if (from->pLibraries) {
+        to->pLibraries = (VkPipeline*)alloc->dupArray(
+            from->pLibraries, from->libraryCount * sizeof(const VkPipeline));
     }
 }
 
-void deepcopy_VkPhysicalDeviceSynchronization2FeaturesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceSynchronization2FeaturesKHR* from,
-    VkPhysicalDeviceSynchronization2FeaturesKHR* to) {
+#endif
+#ifdef VK_KHR_shader_non_semantic_info
+#endif
+#ifdef VK_KHR_present_id
+void deepcopy_VkPresentIdKHR(Allocator* alloc, VkStructureType rootType, const VkPresentIdKHR* from,
+                             VkPresentIdKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8222,32 +9605,16 @@ void deepcopy_VkPhysicalDeviceSynchronization2FeaturesKHR(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-}
-
-void deepcopy_VkQueueFamilyCheckpointProperties2NV(Allocator* alloc, VkStructureType rootType,
-                                                   const VkQueueFamilyCheckpointProperties2NV* from,
-                                                   VkQueueFamilyCheckpointProperties2NV* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    to->pPresentIds = nullptr;
+    if (from->pPresentIds) {
+        to->pPresentIds = (uint64_t*)alloc->dupArray(from->pPresentIds,
+                                                     from->swapchainCount * sizeof(const uint64_t));
     }
 }
 
-void deepcopy_VkCheckpointData2NV(Allocator* alloc, VkStructureType rootType,
-                                  const VkCheckpointData2NV* from, VkCheckpointData2NV* to) {
+void deepcopy_VkPhysicalDevicePresentIdFeaturesKHR(Allocator* alloc, VkStructureType rootType,
+                                                   const VkPhysicalDevicePresentIdFeaturesKHR* from,
+                                                   VkPhysicalDevicePresentIdFeaturesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8265,18 +9632,12 @@ void deepcopy_VkCheckpointData2NV(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pCheckpointMarker = nullptr;
-    if (from->pCheckpointMarker) {
-        to->pCheckpointMarker = (void*)alloc->dupArray(from->pCheckpointMarker, sizeof(uint8_t));
-    }
 }
 
 #endif
-#ifdef VK_KHR_shader_subgroup_uniform_control_flow
-void deepcopy_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* from,
-    VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* to) {
+#ifdef VK_KHR_video_encode_queue
+void deepcopy_VkVideoEncodeInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                   const VkVideoEncodeInfoKHR* from, VkVideoEncodeInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8294,39 +9655,35 @@ void deepcopy_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-}
-
-#endif
-#ifdef VK_KHR_zero_initialize_workgroup_memory
-void deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* from,
-    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    deepcopy_VkVideoPictureResourceInfoKHR(
+        alloc, rootType, &from->srcPictureResource,
+        (VkVideoPictureResourceInfoKHR*)(&to->srcPictureResource));
+    to->pSetupReferenceSlot = nullptr;
+    if (from->pSetupReferenceSlot) {
+        to->pSetupReferenceSlot =
+            (VkVideoReferenceSlotInfoKHR*)alloc->alloc(sizeof(const VkVideoReferenceSlotInfoKHR));
+        deepcopy_VkVideoReferenceSlotInfoKHR(
+            alloc, rootType, from->pSetupReferenceSlot,
+            (VkVideoReferenceSlotInfoKHR*)(to->pSetupReferenceSlot));
     }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    if (from) {
+        to->pReferenceSlots = nullptr;
+        if (from->pReferenceSlots) {
+            to->pReferenceSlots = (VkVideoReferenceSlotInfoKHR*)alloc->alloc(
+                from->referenceSlotCount * sizeof(const VkVideoReferenceSlotInfoKHR));
+            to->referenceSlotCount = from->referenceSlotCount;
+            for (uint32_t i = 0; i < (uint32_t)from->referenceSlotCount; ++i) {
+                deepcopy_VkVideoReferenceSlotInfoKHR(
+                    alloc, rootType, from->pReferenceSlots + i,
+                    (VkVideoReferenceSlotInfoKHR*)(to->pReferenceSlots + i));
+            }
+        }
     }
 }
 
-#endif
-#ifdef VK_KHR_workgroup_memory_explicit_layout
-void deepcopy_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* from,
-    VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* to) {
+void deepcopy_VkVideoEncodeCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+                                           const VkVideoEncodeCapabilitiesKHR* from,
+                                           VkVideoEncodeCapabilitiesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8344,12 +9701,14 @@ void deepcopy_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
+    deepcopy_VkExtent2D(alloc, rootType, &from->inputImageDataFillAlignment,
+                        (VkExtent2D*)(&to->inputImageDataFillAlignment));
 }
 
-#endif
-#ifdef VK_KHR_copy_commands2
-void deepcopy_VkBufferCopy2KHR(Allocator* alloc, VkStructureType rootType,
-                               const VkBufferCopy2KHR* from, VkBufferCopy2KHR* to) {
+void deepcopy_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* from,
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8369,8 +9728,9 @@ void deepcopy_VkBufferCopy2KHR(Allocator* alloc, VkStructureType rootType,
     }
 }
 
-void deepcopy_VkCopyBufferInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                                   const VkCopyBufferInfo2KHR* from, VkCopyBufferInfo2KHR* to) {
+void deepcopy_VkVideoEncodeUsageInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                        const VkVideoEncodeUsageInfoKHR* from,
+                                        VkVideoEncodeUsageInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8388,22 +9748,11 @@ void deepcopy_VkCopyBufferInfo2KHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    if (from) {
-        to->pRegions = nullptr;
-        if (from->pRegions) {
-            to->pRegions =
-                (VkBufferCopy2KHR*)alloc->alloc(from->regionCount * sizeof(const VkBufferCopy2KHR));
-            to->regionCount = from->regionCount;
-            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
-                deepcopy_VkBufferCopy2KHR(alloc, rootType, from->pRegions + i,
-                                          (VkBufferCopy2KHR*)(to->pRegions + i));
-            }
-        }
-    }
 }
 
-void deepcopy_VkImageCopy2KHR(Allocator* alloc, VkStructureType rootType,
-                              const VkImageCopy2KHR* from, VkImageCopy2KHR* to) {
+void deepcopy_VkVideoEncodeRateControlLayerInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                                   const VkVideoEncodeRateControlLayerInfoKHR* from,
+                                                   VkVideoEncodeRateControlLayerInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8421,17 +9770,11 @@ void deepcopy_VkImageCopy2KHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource,
-                                      (VkImageSubresourceLayers*)(&to->srcSubresource));
-    deepcopy_VkOffset3D(alloc, rootType, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
-    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource,
-                                      (VkImageSubresourceLayers*)(&to->dstSubresource));
-    deepcopy_VkOffset3D(alloc, rootType, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
-    deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
 }
 
-void deepcopy_VkCopyImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                                  const VkCopyImageInfo2KHR* from, VkCopyImageInfo2KHR* to) {
+void deepcopy_VkVideoEncodeRateControlInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoEncodeRateControlInfoKHR* from,
+                                              VkVideoEncodeRateControlInfoKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8450,21 +9793,25 @@ void deepcopy_VkCopyImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
     if (from) {
-        to->pRegions = nullptr;
-        if (from->pRegions) {
-            to->pRegions =
-                (VkImageCopy2KHR*)alloc->alloc(from->regionCount * sizeof(const VkImageCopy2KHR));
-            to->regionCount = from->regionCount;
-            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
-                deepcopy_VkImageCopy2KHR(alloc, rootType, from->pRegions + i,
-                                         (VkImageCopy2KHR*)(to->pRegions + i));
+        to->pLayers = nullptr;
+        if (from->pLayers) {
+            to->pLayers = (VkVideoEncodeRateControlLayerInfoKHR*)alloc->alloc(
+                from->layerCount * sizeof(const VkVideoEncodeRateControlLayerInfoKHR));
+            to->layerCount = from->layerCount;
+            for (uint32_t i = 0; i < (uint32_t)from->layerCount; ++i) {
+                deepcopy_VkVideoEncodeRateControlLayerInfoKHR(
+                    alloc, rootType, from->pLayers + i,
+                    (VkVideoEncodeRateControlLayerInfoKHR*)(to->pLayers + i));
             }
         }
     }
 }
 
-void deepcopy_VkBufferImageCopy2KHR(Allocator* alloc, VkStructureType rootType,
-                                    const VkBufferImageCopy2KHR* from, VkBufferImageCopy2KHR* to) {
+#endif
+#ifdef VK_KHR_synchronization2
+void deepcopy_VkQueueFamilyCheckpointProperties2NV(Allocator* alloc, VkStructureType rootType,
+                                                   const VkQueueFamilyCheckpointProperties2NV* from,
+                                                   VkQueueFamilyCheckpointProperties2NV* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8482,15 +9829,10 @@ void deepcopy_VkBufferImageCopy2KHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->imageSubresource,
-                                      (VkImageSubresourceLayers*)(&to->imageSubresource));
-    deepcopy_VkOffset3D(alloc, rootType, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
-    deepcopy_VkExtent3D(alloc, rootType, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
 }
 
-void deepcopy_VkCopyBufferToImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                                          const VkCopyBufferToImageInfo2KHR* from,
-                                          VkCopyBufferToImageInfo2KHR* to) {
+void deepcopy_VkCheckpointData2NV(Allocator* alloc, VkStructureType rootType,
+                                  const VkCheckpointData2NV* from, VkCheckpointData2NV* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8508,23 +9850,18 @@ void deepcopy_VkCopyBufferToImageInfo2KHR(Allocator* alloc, VkStructureType root
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    if (from) {
-        to->pRegions = nullptr;
-        if (from->pRegions) {
-            to->pRegions = (VkBufferImageCopy2KHR*)alloc->alloc(
-                from->regionCount * sizeof(const VkBufferImageCopy2KHR));
-            to->regionCount = from->regionCount;
-            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
-                deepcopy_VkBufferImageCopy2KHR(alloc, rootType, from->pRegions + i,
-                                               (VkBufferImageCopy2KHR*)(to->pRegions + i));
-            }
-        }
+    to->pCheckpointMarker = nullptr;
+    if (from->pCheckpointMarker) {
+        to->pCheckpointMarker = (void*)alloc->dupArray(from->pCheckpointMarker, sizeof(uint8_t));
     }
 }
 
-void deepcopy_VkCopyImageToBufferInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                                          const VkCopyImageToBufferInfo2KHR* from,
-                                          VkCopyImageToBufferInfo2KHR* to) {
+#endif
+#ifdef VK_KHR_fragment_shader_barycentric
+void deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* from,
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8542,22 +9879,12 @@ void deepcopy_VkCopyImageToBufferInfo2KHR(Allocator* alloc, VkStructureType root
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    if (from) {
-        to->pRegions = nullptr;
-        if (from->pRegions) {
-            to->pRegions = (VkBufferImageCopy2KHR*)alloc->alloc(
-                from->regionCount * sizeof(const VkBufferImageCopy2KHR));
-            to->regionCount = from->regionCount;
-            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
-                deepcopy_VkBufferImageCopy2KHR(alloc, rootType, from->pRegions + i,
-                                               (VkBufferImageCopy2KHR*)(to->pRegions + i));
-            }
-        }
-    }
 }
 
-void deepcopy_VkImageBlit2KHR(Allocator* alloc, VkStructureType rootType,
-                              const VkImageBlit2KHR* from, VkImageBlit2KHR* to) {
+void deepcopy_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* from,
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8575,22 +9902,14 @@ void deepcopy_VkImageBlit2KHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource,
-                                      (VkImageSubresourceLayers*)(&to->srcSubresource));
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        deepcopy_VkOffset3D(alloc, rootType, from->srcOffsets + i,
-                            (VkOffset3D*)(to->srcOffsets + i));
-    }
-    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource,
-                                      (VkImageSubresourceLayers*)(&to->dstSubresource));
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        deepcopy_VkOffset3D(alloc, rootType, from->dstOffsets + i,
-                            (VkOffset3D*)(to->dstOffsets + i));
-    }
 }
 
-void deepcopy_VkBlitImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                                  const VkBlitImageInfo2KHR* from, VkBlitImageInfo2KHR* to) {
+#endif
+#ifdef VK_KHR_shader_subgroup_uniform_control_flow
+void deepcopy_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* from,
+    VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8608,22 +9927,16 @@ void deepcopy_VkBlitImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    if (from) {
-        to->pRegions = nullptr;
-        if (from->pRegions) {
-            to->pRegions =
-                (VkImageBlit2KHR*)alloc->alloc(from->regionCount * sizeof(const VkImageBlit2KHR));
-            to->regionCount = from->regionCount;
-            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
-                deepcopy_VkImageBlit2KHR(alloc, rootType, from->pRegions + i,
-                                         (VkImageBlit2KHR*)(to->pRegions + i));
-            }
-        }
-    }
 }
 
-void deepcopy_VkImageResolve2KHR(Allocator* alloc, VkStructureType rootType,
-                                 const VkImageResolve2KHR* from, VkImageResolve2KHR* to) {
+#endif
+#ifdef VK_KHR_zero_initialize_workgroup_memory
+#endif
+#ifdef VK_KHR_workgroup_memory_explicit_layout
+void deepcopy_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* from,
+    VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8641,18 +9954,18 @@ void deepcopy_VkImageResolve2KHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->srcSubresource,
-                                      (VkImageSubresourceLayers*)(&to->srcSubresource));
-    deepcopy_VkOffset3D(alloc, rootType, &from->srcOffset, (VkOffset3D*)(&to->srcOffset));
-    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->dstSubresource,
-                                      (VkImageSubresourceLayers*)(&to->dstSubresource));
-    deepcopy_VkOffset3D(alloc, rootType, &from->dstOffset, (VkOffset3D*)(&to->dstOffset));
-    deepcopy_VkExtent3D(alloc, rootType, &from->extent, (VkExtent3D*)(&to->extent));
 }
 
-void deepcopy_VkResolveImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                                     const VkResolveImageInfo2KHR* from,
-                                     VkResolveImageInfo2KHR* to) {
+#endif
+#ifdef VK_KHR_copy_commands2
+#endif
+#ifdef VK_KHR_format_feature_flags2
+#endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+void deepcopy_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* from,
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8670,49 +9983,26 @@ void deepcopy_VkResolveImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    if (from) {
-        to->pRegions = nullptr;
-        if (from->pRegions) {
-            to->pRegions = (VkImageResolve2KHR*)alloc->alloc(from->regionCount *
-                                                             sizeof(const VkImageResolve2KHR));
-            to->regionCount = from->regionCount;
-            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
-                deepcopy_VkImageResolve2KHR(alloc, rootType, from->pRegions + i,
-                                            (VkImageResolve2KHR*)(to->pRegions + i));
-            }
-        }
-    }
 }
 
-#endif
-#ifdef VK_KHR_format_feature_flags2
-void deepcopy_VkFormatProperties3KHR(Allocator* alloc, VkStructureType rootType,
-                                     const VkFormatProperties3KHR* from,
-                                     VkFormatProperties3KHR* to) {
+void deepcopy_VkTraceRaysIndirectCommand2KHR(Allocator* alloc, VkStructureType rootType,
+                                             const VkTraceRaysIndirectCommand2KHR* from,
+                                             VkTraceRaysIndirectCommand2KHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
 }
 
 #endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
-void deepcopy_VkPhysicalDeviceMaintenance4FeaturesKHR(
-    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance4FeaturesKHR* from,
-    VkPhysicalDeviceMaintenance4FeaturesKHR* to) {
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+void deepcopy_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* from,
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8732,32 +10022,18 @@ void deepcopy_VkPhysicalDeviceMaintenance4FeaturesKHR(
     }
 }
 
-void deepcopy_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceMaintenance4PropertiesKHR* from,
-    VkPhysicalDeviceMaintenance4PropertiesKHR* to) {
+#endif
+#ifdef VK_ANDROID_native_buffer
+void deepcopy_VkNativeBufferUsage2ANDROID(Allocator* alloc, VkStructureType rootType,
+                                          const VkNativeBufferUsage2ANDROID* from,
+                                          VkNativeBufferUsage2ANDROID* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
 }
 
-void deepcopy_VkDeviceBufferMemoryRequirementsKHR(Allocator* alloc, VkStructureType rootType,
-                                                  const VkDeviceBufferMemoryRequirementsKHR* from,
-                                                  VkDeviceBufferMemoryRequirementsKHR* to) {
+void deepcopy_VkNativeBufferANDROID(Allocator* alloc, VkStructureType rootType,
+                                    const VkNativeBufferANDROID* from, VkNativeBufferANDROID* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8775,17 +10051,17 @@ void deepcopy_VkDeviceBufferMemoryRequirementsKHR(Allocator* alloc, VkStructureT
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pCreateInfo = nullptr;
-    if (from->pCreateInfo) {
-        to->pCreateInfo = (VkBufferCreateInfo*)alloc->alloc(sizeof(const VkBufferCreateInfo));
-        deepcopy_VkBufferCreateInfo(alloc, rootType, from->pCreateInfo,
-                                    (VkBufferCreateInfo*)(to->pCreateInfo));
+    to->handle = nullptr;
+    if (from->handle) {
+        to->handle = (uint32_t*)alloc->dupArray(from->handle, sizeof(const uint32_t));
     }
+    deepcopy_VkNativeBufferUsage2ANDROID(alloc, rootType, &from->usage2,
+                                         (VkNativeBufferUsage2ANDROID*)(&to->usage2));
 }
 
-void deepcopy_VkDeviceImageMemoryRequirementsKHR(Allocator* alloc, VkStructureType rootType,
-                                                 const VkDeviceImageMemoryRequirementsKHR* from,
-                                                 VkDeviceImageMemoryRequirementsKHR* to) {
+void deepcopy_VkSwapchainImageCreateInfoANDROID(Allocator* alloc, VkStructureType rootType,
+                                                const VkSwapchainImageCreateInfoANDROID* from,
+                                                VkSwapchainImageCreateInfoANDROID* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8803,18 +10079,12 @@ void deepcopy_VkDeviceImageMemoryRequirementsKHR(Allocator* alloc, VkStructureTy
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pCreateInfo = nullptr;
-    if (from->pCreateInfo) {
-        to->pCreateInfo = (VkImageCreateInfo*)alloc->alloc(sizeof(const VkImageCreateInfo));
-        deepcopy_VkImageCreateInfo(alloc, rootType, from->pCreateInfo,
-                                   (VkImageCreateInfo*)(to->pCreateInfo));
-    }
 }
 
-#endif
-#ifdef VK_ANDROID_native_buffer
-void deepcopy_VkNativeBufferANDROID(Allocator* alloc, VkStructureType rootType,
-                                    const VkNativeBufferANDROID* from, VkNativeBufferANDROID* to) {
+void deepcopy_VkPhysicalDevicePresentationPropertiesANDROID(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePresentationPropertiesANDROID* from,
+    VkPhysicalDevicePresentationPropertiesANDROID* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -8832,10 +10102,6 @@ void deepcopy_VkNativeBufferANDROID(Allocator* alloc, VkStructureType rootType,
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->handle = nullptr;
-    if (from->handle) {
-        to->handle = (uint32_t*)alloc->dupArray(from->handle, sizeof(const uint32_t));
-    }
 }
 
 #endif
@@ -9275,45 +10541,6 @@ void deepcopy_VkVideoEncodeH264CapabilitiesEXT(Allocator* alloc, VkStructureType
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkExtent2D(alloc, rootType, &from->minPictureSizeInMbs,
-                        (VkExtent2D*)(&to->minPictureSizeInMbs));
-    deepcopy_VkExtent2D(alloc, rootType, &from->maxPictureSizeInMbs,
-                        (VkExtent2D*)(&to->maxPictureSizeInMbs));
-    deepcopy_VkExtent2D(alloc, rootType, &from->inputImageDataAlignment,
-                        (VkExtent2D*)(&to->inputImageDataAlignment));
-    deepcopy_VkExtensionProperties(alloc, rootType, &from->stdExtensionVersion,
-                                   (VkExtensionProperties*)(&to->stdExtensionVersion));
-}
-
-void deepcopy_VkVideoEncodeH264SessionCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType, const VkVideoEncodeH264SessionCreateInfoEXT* from,
-    VkVideoEncodeH264SessionCreateInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    deepcopy_VkExtent2D(alloc, rootType, &from->maxPictureSizeInMbs,
-                        (VkExtent2D*)(&to->maxPictureSizeInMbs));
-    to->pStdExtensionVersion = nullptr;
-    if (from->pStdExtensionVersion) {
-        to->pStdExtensionVersion =
-            (VkExtensionProperties*)alloc->alloc(sizeof(const VkExtensionProperties));
-        deepcopy_VkExtensionProperties(alloc, rootType, from->pStdExtensionVersion,
-                                       (VkExtensionProperties*)(to->pStdExtensionVersion));
-    }
 }
 
 void deepcopy_VkVideoEncodeH264SessionParametersAddInfoEXT(
@@ -9337,15 +10564,15 @@ void deepcopy_VkVideoEncodeH264SessionParametersAddInfoEXT(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pSpsStd = nullptr;
-    if (from->pSpsStd) {
-        to->pSpsStd = (StdVideoH264SequenceParameterSet*)alloc->dupArray(
-            from->pSpsStd, from->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
+    to->pStdSPSs = nullptr;
+    if (from->pStdSPSs) {
+        to->pStdSPSs = (StdVideoH264SequenceParameterSet*)alloc->dupArray(
+            from->pStdSPSs, from->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
     }
-    to->pPpsStd = nullptr;
-    if (from->pPpsStd) {
-        to->pPpsStd = (StdVideoH264PictureParameterSet*)alloc->dupArray(
-            from->pPpsStd, from->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
+    to->pStdPPSs = nullptr;
+    if (from->pStdPPSs) {
+        to->pStdPPSs = (StdVideoH264PictureParameterSet*)alloc->dupArray(
+            from->pStdPPSs, from->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
     }
 }
 
@@ -9380,9 +10607,9 @@ void deepcopy_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     }
 }
 
-void deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                              const VkVideoEncodeH264DpbSlotInfoEXT* from,
-                                              VkVideoEncodeH264DpbSlotInfoEXT* to) {
+void deepcopy_VkVideoEncodeH264NaluSliceInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                const VkVideoEncodeH264NaluSliceInfoEXT* from,
+                                                VkVideoEncodeH264NaluSliceInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -9400,16 +10627,21 @@ void deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(Allocator* alloc, VkStructureType
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pStdPictureInfo = nullptr;
-    if (from->pStdPictureInfo) {
-        to->pStdPictureInfo = (StdVideoEncodeH264PictureInfo*)alloc->dupArray(
-            from->pStdPictureInfo, sizeof(const StdVideoEncodeH264PictureInfo));
+    to->pStdReferenceFinalLists = nullptr;
+    if (from->pStdReferenceFinalLists) {
+        to->pStdReferenceFinalLists = (StdVideoEncodeH264ReferenceListsInfo*)alloc->dupArray(
+            from->pStdReferenceFinalLists, sizeof(const StdVideoEncodeH264ReferenceListsInfo));
+    }
+    to->pStdSliceHeader = nullptr;
+    if (from->pStdSliceHeader) {
+        to->pStdSliceHeader = (StdVideoEncodeH264SliceHeader*)alloc->dupArray(
+            from->pStdSliceHeader, sizeof(const StdVideoEncodeH264SliceHeader));
     }
 }
 
-void deepcopy_VkVideoEncodeH264NaluSliceEXT(Allocator* alloc, VkStructureType rootType,
-                                            const VkVideoEncodeH264NaluSliceEXT* from,
-                                            VkVideoEncodeH264NaluSliceEXT* to) {
+void deepcopy_VkVideoEncodeH264VclFrameInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                               const VkVideoEncodeH264VclFrameInfoEXT* from,
+                                               VkVideoEncodeH264VclFrameInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -9427,42 +10659,34 @@ void deepcopy_VkVideoEncodeH264NaluSliceEXT(Allocator* alloc, VkStructureType ro
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pSliceHeaderStd = nullptr;
-    if (from->pSliceHeaderStd) {
-        to->pSliceHeaderStd = (StdVideoEncodeH264SliceHeader*)alloc->dupArray(
-            from->pSliceHeaderStd, sizeof(const StdVideoEncodeH264SliceHeader));
+    to->pStdReferenceFinalLists = nullptr;
+    if (from->pStdReferenceFinalLists) {
+        to->pStdReferenceFinalLists = (StdVideoEncodeH264ReferenceListsInfo*)alloc->dupArray(
+            from->pStdReferenceFinalLists, sizeof(const StdVideoEncodeH264ReferenceListsInfo));
     }
     if (from) {
-        to->pRefFinalList0Entries = nullptr;
-        if (from->pRefFinalList0Entries) {
-            to->pRefFinalList0Entries = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(
-                from->refFinalList0EntryCount * sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-            to->refFinalList0EntryCount = from->refFinalList0EntryCount;
-            for (uint32_t i = 0; i < (uint32_t)from->refFinalList0EntryCount; ++i) {
-                deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(
-                    alloc, rootType, from->pRefFinalList0Entries + i,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pRefFinalList0Entries + i));
+        to->pNaluSliceEntries = nullptr;
+        if (from->pNaluSliceEntries) {
+            to->pNaluSliceEntries = (VkVideoEncodeH264NaluSliceInfoEXT*)alloc->alloc(
+                from->naluSliceEntryCount * sizeof(const VkVideoEncodeH264NaluSliceInfoEXT));
+            to->naluSliceEntryCount = from->naluSliceEntryCount;
+            for (uint32_t i = 0; i < (uint32_t)from->naluSliceEntryCount; ++i) {
+                deepcopy_VkVideoEncodeH264NaluSliceInfoEXT(
+                    alloc, rootType, from->pNaluSliceEntries + i,
+                    (VkVideoEncodeH264NaluSliceInfoEXT*)(to->pNaluSliceEntries + i));
             }
         }
     }
-    if (from) {
-        to->pRefFinalList1Entries = nullptr;
-        if (from->pRefFinalList1Entries) {
-            to->pRefFinalList1Entries = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(
-                from->refFinalList1EntryCount * sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-            to->refFinalList1EntryCount = from->refFinalList1EntryCount;
-            for (uint32_t i = 0; i < (uint32_t)from->refFinalList1EntryCount; ++i) {
-                deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(
-                    alloc, rootType, from->pRefFinalList1Entries + i,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pRefFinalList1Entries + i));
-            }
-        }
+    to->pStdPictureInfo = nullptr;
+    if (from->pStdPictureInfo) {
+        to->pStdPictureInfo = (StdVideoEncodeH264PictureInfo*)alloc->dupArray(
+            from->pStdPictureInfo, sizeof(const StdVideoEncodeH264PictureInfo));
     }
 }
 
-void deepcopy_VkVideoEncodeH264VclFrameInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                               const VkVideoEncodeH264VclFrameInfoEXT* from,
-                                               VkVideoEncodeH264VclFrameInfoEXT* to) {
+void deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoEncodeH264DpbSlotInfoEXT* from,
+                                              VkVideoEncodeH264DpbSlotInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -9480,61 +10704,16 @@ void deepcopy_VkVideoEncodeH264VclFrameInfoEXT(Allocator* alloc, VkStructureType
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    if (from) {
-        to->pRefDefaultFinalList0Entries = nullptr;
-        if (from->pRefDefaultFinalList0Entries) {
-            to->pRefDefaultFinalList0Entries = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(
-                from->refDefaultFinalList0EntryCount *
-                sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-            to->refDefaultFinalList0EntryCount = from->refDefaultFinalList0EntryCount;
-            for (uint32_t i = 0; i < (uint32_t)from->refDefaultFinalList0EntryCount; ++i) {
-                deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(
-                    alloc, rootType, from->pRefDefaultFinalList0Entries + i,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pRefDefaultFinalList0Entries + i));
-            }
-        }
-    }
-    if (from) {
-        to->pRefDefaultFinalList1Entries = nullptr;
-        if (from->pRefDefaultFinalList1Entries) {
-            to->pRefDefaultFinalList1Entries = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(
-                from->refDefaultFinalList1EntryCount *
-                sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-            to->refDefaultFinalList1EntryCount = from->refDefaultFinalList1EntryCount;
-            for (uint32_t i = 0; i < (uint32_t)from->refDefaultFinalList1EntryCount; ++i) {
-                deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(
-                    alloc, rootType, from->pRefDefaultFinalList1Entries + i,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pRefDefaultFinalList1Entries + i));
-            }
-        }
-    }
-    if (from) {
-        to->pNaluSliceEntries = nullptr;
-        if (from->pNaluSliceEntries) {
-            to->pNaluSliceEntries = (VkVideoEncodeH264NaluSliceEXT*)alloc->alloc(
-                from->naluSliceEntryCount * sizeof(const VkVideoEncodeH264NaluSliceEXT));
-            to->naluSliceEntryCount = from->naluSliceEntryCount;
-            for (uint32_t i = 0; i < (uint32_t)from->naluSliceEntryCount; ++i) {
-                deepcopy_VkVideoEncodeH264NaluSliceEXT(
-                    alloc, rootType, from->pNaluSliceEntries + i,
-                    (VkVideoEncodeH264NaluSliceEXT*)(to->pNaluSliceEntries + i));
-            }
-        }
-    }
-    to->pCurrentPictureInfo = nullptr;
-    if (from->pCurrentPictureInfo) {
-        to->pCurrentPictureInfo = (VkVideoEncodeH264DpbSlotInfoEXT*)alloc->alloc(
-            sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-        deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(
-            alloc, rootType, from->pCurrentPictureInfo,
-            (VkVideoEncodeH264DpbSlotInfoEXT*)(to->pCurrentPictureInfo));
+    to->pStdReferenceInfo = nullptr;
+    if (from->pStdReferenceInfo) {
+        to->pStdReferenceInfo = (StdVideoEncodeH264ReferenceInfo*)alloc->dupArray(
+            from->pStdReferenceInfo, sizeof(const StdVideoEncodeH264ReferenceInfo));
     }
 }
 
-void deepcopy_VkVideoEncodeH264EmitPictureParametersEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkVideoEncodeH264EmitPictureParametersEXT* from,
-    VkVideoEncodeH264EmitPictureParametersEXT* to) {
+void deepcopy_VkVideoEncodeH264ProfileInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoEncodeH264ProfileInfoEXT* from,
+                                              VkVideoEncodeH264ProfileInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -9552,16 +10731,11 @@ void deepcopy_VkVideoEncodeH264EmitPictureParametersEXT(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->ppsIdEntries = nullptr;
-    if (from->ppsIdEntries) {
-        to->ppsIdEntries = (uint8_t*)alloc->dupArray(from->ppsIdEntries,
-                                                     from->ppsIdEntryCount * sizeof(const uint8_t));
-    }
 }
 
-void deepcopy_VkVideoEncodeH264ProfileEXT(Allocator* alloc, VkStructureType rootType,
-                                          const VkVideoEncodeH264ProfileEXT* from,
-                                          VkVideoEncodeH264ProfileEXT* to) {
+void deepcopy_VkVideoEncodeH264RateControlInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                  const VkVideoEncodeH264RateControlInfoEXT* from,
+                                                  VkVideoEncodeH264RateControlInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -9581,11 +10755,26 @@ void deepcopy_VkVideoEncodeH264ProfileEXT(Allocator* alloc, VkStructureType root
     }
 }
 
-#endif
-#ifdef VK_EXT_video_encode_h265
-void deepcopy_VkVideoEncodeH265CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
-                                               const VkVideoEncodeH265CapabilitiesEXT* from,
-                                               VkVideoEncodeH265CapabilitiesEXT* to) {
+void deepcopy_VkVideoEncodeH264QpEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkVideoEncodeH264QpEXT* from,
+                                     VkVideoEncodeH264QpEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+}
+
+void deepcopy_VkVideoEncodeH264FrameSizeEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkVideoEncodeH264FrameSizeEXT* from,
+                                            VkVideoEncodeH264FrameSizeEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+}
+
+void deepcopy_VkVideoEncodeH264RateControlLayerInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkVideoEncodeH264RateControlLayerInfoEXT* from,
+    VkVideoEncodeH264RateControlLayerInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -9603,15 +10792,21 @@ void deepcopy_VkVideoEncodeH265CapabilitiesEXT(Allocator* alloc, VkStructureType
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    deepcopy_VkExtent2D(alloc, rootType, &from->inputImageDataAlignment,
-                        (VkExtent2D*)(&to->inputImageDataAlignment));
-    deepcopy_VkExtensionProperties(alloc, rootType, &from->stdExtensionVersion,
-                                   (VkExtensionProperties*)(&to->stdExtensionVersion));
+    deepcopy_VkVideoEncodeH264QpEXT(alloc, rootType, &from->initialRcQp,
+                                    (VkVideoEncodeH264QpEXT*)(&to->initialRcQp));
+    deepcopy_VkVideoEncodeH264QpEXT(alloc, rootType, &from->minQp,
+                                    (VkVideoEncodeH264QpEXT*)(&to->minQp));
+    deepcopy_VkVideoEncodeH264QpEXT(alloc, rootType, &from->maxQp,
+                                    (VkVideoEncodeH264QpEXT*)(&to->maxQp));
+    deepcopy_VkVideoEncodeH264FrameSizeEXT(alloc, rootType, &from->maxFrameSize,
+                                           (VkVideoEncodeH264FrameSizeEXT*)(&to->maxFrameSize));
 }
 
-void deepcopy_VkVideoEncodeH265SessionCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType, const VkVideoEncodeH265SessionCreateInfoEXT* from,
-    VkVideoEncodeH265SessionCreateInfoEXT* to) {
+#endif
+#ifdef VK_EXT_video_encode_h265
+void deepcopy_VkVideoEncodeH265CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
+                                               const VkVideoEncodeH265CapabilitiesEXT* from,
+                                               VkVideoEncodeH265CapabilitiesEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -9629,13 +10824,6 @@ void deepcopy_VkVideoEncodeH265SessionCreateInfoEXT(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pStdExtensionVersion = nullptr;
-    if (from->pStdExtensionVersion) {
-        to->pStdExtensionVersion =
-            (VkExtensionProperties*)alloc->alloc(sizeof(const VkExtensionProperties));
-        deepcopy_VkExtensionProperties(alloc, rootType, from->pStdExtensionVersion,
-                                       (VkExtensionProperties*)(to->pStdExtensionVersion));
-    }
 }
 
 void deepcopy_VkVideoEncodeH265SessionParametersAddInfoEXT(
@@ -9659,20 +10847,20 @@ void deepcopy_VkVideoEncodeH265SessionParametersAddInfoEXT(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pVpsStd = nullptr;
-    if (from->pVpsStd) {
-        to->pVpsStd = (StdVideoH265VideoParameterSet*)alloc->dupArray(
-            from->pVpsStd, from->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
+    to->pStdVPSs = nullptr;
+    if (from->pStdVPSs) {
+        to->pStdVPSs = (StdVideoH265VideoParameterSet*)alloc->dupArray(
+            from->pStdVPSs, from->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
     }
-    to->pSpsStd = nullptr;
-    if (from->pSpsStd) {
-        to->pSpsStd = (StdVideoH265SequenceParameterSet*)alloc->dupArray(
-            from->pSpsStd, from->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
+    to->pStdSPSs = nullptr;
+    if (from->pStdSPSs) {
+        to->pStdSPSs = (StdVideoH265SequenceParameterSet*)alloc->dupArray(
+            from->pStdSPSs, from->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
     }
-    to->pPpsStd = nullptr;
-    if (from->pPpsStd) {
-        to->pPpsStd = (StdVideoH265PictureParameterSet*)alloc->dupArray(
-            from->pPpsStd, from->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
+    to->pStdPPSs = nullptr;
+    if (from->pStdPPSs) {
+        to->pStdPPSs = (StdVideoH265PictureParameterSet*)alloc->dupArray(
+            from->pStdPPSs, from->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
     }
 }
 
@@ -9707,89 +10895,10 @@ void deepcopy_VkVideoEncodeH265SessionParametersCreateInfoEXT(
     }
 }
 
-void deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                              const VkVideoEncodeH265DpbSlotInfoEXT* from,
-                                              VkVideoEncodeH265DpbSlotInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    to->pStdReferenceInfo = nullptr;
-    if (from->pStdReferenceInfo) {
-        to->pStdReferenceInfo = (StdVideoEncodeH265ReferenceInfo*)alloc->dupArray(
-            from->pStdReferenceInfo, sizeof(const StdVideoEncodeH265ReferenceInfo));
-    }
-}
-
-void deepcopy_VkVideoEncodeH265ReferenceListsEXT(Allocator* alloc, VkStructureType rootType,
-                                                 const VkVideoEncodeH265ReferenceListsEXT* from,
-                                                 VkVideoEncodeH265ReferenceListsEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    if (from) {
-        to->pReferenceList0Entries = nullptr;
-        if (from->pReferenceList0Entries) {
-            to->pReferenceList0Entries = (VkVideoEncodeH265DpbSlotInfoEXT*)alloc->alloc(
-                from->referenceList0EntryCount * sizeof(const VkVideoEncodeH265DpbSlotInfoEXT));
-            to->referenceList0EntryCount = from->referenceList0EntryCount;
-            for (uint32_t i = 0; i < (uint32_t)from->referenceList0EntryCount; ++i) {
-                deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(
-                    alloc, rootType, from->pReferenceList0Entries + i,
-                    (VkVideoEncodeH265DpbSlotInfoEXT*)(to->pReferenceList0Entries + i));
-            }
-        }
-    }
-    if (from) {
-        to->pReferenceList1Entries = nullptr;
-        if (from->pReferenceList1Entries) {
-            to->pReferenceList1Entries = (VkVideoEncodeH265DpbSlotInfoEXT*)alloc->alloc(
-                from->referenceList1EntryCount * sizeof(const VkVideoEncodeH265DpbSlotInfoEXT));
-            to->referenceList1EntryCount = from->referenceList1EntryCount;
-            for (uint32_t i = 0; i < (uint32_t)from->referenceList1EntryCount; ++i) {
-                deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(
-                    alloc, rootType, from->pReferenceList1Entries + i,
-                    (VkVideoEncodeH265DpbSlotInfoEXT*)(to->pReferenceList1Entries + i));
-            }
-        }
-    }
-    to->pReferenceModifications = nullptr;
-    if (from->pReferenceModifications) {
-        to->pReferenceModifications = (StdVideoEncodeH265ReferenceModifications*)alloc->dupArray(
-            from->pReferenceModifications, sizeof(const StdVideoEncodeH265ReferenceModifications));
-    }
-}
-
-void deepcopy_VkVideoEncodeH265NaluSliceEXT(Allocator* alloc, VkStructureType rootType,
-                                            const VkVideoEncodeH265NaluSliceEXT* from,
-                                            VkVideoEncodeH265NaluSliceEXT* to) {
+void deepcopy_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkVideoEncodeH265NaluSliceSegmentInfoEXT* from,
+    VkVideoEncodeH265NaluSliceSegmentInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -9807,18 +10916,15 @@ void deepcopy_VkVideoEncodeH265NaluSliceEXT(Allocator* alloc, VkStructureType ro
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pReferenceFinalLists = nullptr;
-    if (from->pReferenceFinalLists) {
-        to->pReferenceFinalLists = (VkVideoEncodeH265ReferenceListsEXT*)alloc->alloc(
-            sizeof(const VkVideoEncodeH265ReferenceListsEXT));
-        deepcopy_VkVideoEncodeH265ReferenceListsEXT(
-            alloc, rootType, from->pReferenceFinalLists,
-            (VkVideoEncodeH265ReferenceListsEXT*)(to->pReferenceFinalLists));
+    to->pStdReferenceFinalLists = nullptr;
+    if (from->pStdReferenceFinalLists) {
+        to->pStdReferenceFinalLists = (StdVideoEncodeH265ReferenceListsInfo*)alloc->dupArray(
+            from->pStdReferenceFinalLists, sizeof(const StdVideoEncodeH265ReferenceListsInfo));
     }
-    to->pSliceHeaderStd = nullptr;
-    if (from->pSliceHeaderStd) {
-        to->pSliceHeaderStd = (StdVideoEncodeH265SliceHeader*)alloc->dupArray(
-            from->pSliceHeaderStd, sizeof(const StdVideoEncodeH265SliceHeader));
+    to->pStdSliceSegmentHeader = nullptr;
+    if (from->pStdSliceSegmentHeader) {
+        to->pStdSliceSegmentHeader = (StdVideoEncodeH265SliceSegmentHeader*)alloc->dupArray(
+            from->pStdSliceSegmentHeader, sizeof(const StdVideoEncodeH265SliceSegmentHeader));
     }
 }
 
@@ -9842,38 +10948,35 @@ void deepcopy_VkVideoEncodeH265VclFrameInfoEXT(Allocator* alloc, VkStructureType
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pReferenceFinalLists = nullptr;
-    if (from->pReferenceFinalLists) {
-        to->pReferenceFinalLists = (VkVideoEncodeH265ReferenceListsEXT*)alloc->alloc(
-            sizeof(const VkVideoEncodeH265ReferenceListsEXT));
-        deepcopy_VkVideoEncodeH265ReferenceListsEXT(
-            alloc, rootType, from->pReferenceFinalLists,
-            (VkVideoEncodeH265ReferenceListsEXT*)(to->pReferenceFinalLists));
+    to->pStdReferenceFinalLists = nullptr;
+    if (from->pStdReferenceFinalLists) {
+        to->pStdReferenceFinalLists = (StdVideoEncodeH265ReferenceListsInfo*)alloc->dupArray(
+            from->pStdReferenceFinalLists, sizeof(const StdVideoEncodeH265ReferenceListsInfo));
     }
     if (from) {
-        to->pNaluSliceEntries = nullptr;
-        if (from->pNaluSliceEntries) {
-            to->pNaluSliceEntries = (VkVideoEncodeH265NaluSliceEXT*)alloc->alloc(
-                from->naluSliceEntryCount * sizeof(const VkVideoEncodeH265NaluSliceEXT));
-            to->naluSliceEntryCount = from->naluSliceEntryCount;
-            for (uint32_t i = 0; i < (uint32_t)from->naluSliceEntryCount; ++i) {
-                deepcopy_VkVideoEncodeH265NaluSliceEXT(
-                    alloc, rootType, from->pNaluSliceEntries + i,
-                    (VkVideoEncodeH265NaluSliceEXT*)(to->pNaluSliceEntries + i));
+        to->pNaluSliceSegmentEntries = nullptr;
+        if (from->pNaluSliceSegmentEntries) {
+            to->pNaluSliceSegmentEntries = (VkVideoEncodeH265NaluSliceSegmentInfoEXT*)alloc->alloc(
+                from->naluSliceSegmentEntryCount *
+                sizeof(const VkVideoEncodeH265NaluSliceSegmentInfoEXT));
+            to->naluSliceSegmentEntryCount = from->naluSliceSegmentEntryCount;
+            for (uint32_t i = 0; i < (uint32_t)from->naluSliceSegmentEntryCount; ++i) {
+                deepcopy_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+                    alloc, rootType, from->pNaluSliceSegmentEntries + i,
+                    (VkVideoEncodeH265NaluSliceSegmentInfoEXT*)(to->pNaluSliceSegmentEntries + i));
             }
         }
     }
-    to->pCurrentPictureInfo = nullptr;
-    if (from->pCurrentPictureInfo) {
-        to->pCurrentPictureInfo = (StdVideoEncodeH265PictureInfo*)alloc->dupArray(
-            from->pCurrentPictureInfo, sizeof(const StdVideoEncodeH265PictureInfo));
+    to->pStdPictureInfo = nullptr;
+    if (from->pStdPictureInfo) {
+        to->pStdPictureInfo = (StdVideoEncodeH265PictureInfo*)alloc->dupArray(
+            from->pStdPictureInfo, sizeof(const StdVideoEncodeH265PictureInfo));
     }
 }
 
-void deepcopy_VkVideoEncodeH265EmitPictureParametersEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkVideoEncodeH265EmitPictureParametersEXT* from,
-    VkVideoEncodeH265EmitPictureParametersEXT* to) {
+void deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoEncodeH265DpbSlotInfoEXT* from,
+                                              VkVideoEncodeH265DpbSlotInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -9891,16 +10994,16 @@ void deepcopy_VkVideoEncodeH265EmitPictureParametersEXT(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->ppsIdEntries = nullptr;
-    if (from->ppsIdEntries) {
-        to->ppsIdEntries = (uint8_t*)alloc->dupArray(from->ppsIdEntries,
-                                                     from->ppsIdEntryCount * sizeof(const uint8_t));
+    to->pStdReferenceInfo = nullptr;
+    if (from->pStdReferenceInfo) {
+        to->pStdReferenceInfo = (StdVideoEncodeH265ReferenceInfo*)alloc->dupArray(
+            from->pStdReferenceInfo, sizeof(const StdVideoEncodeH265ReferenceInfo));
     }
 }
 
-void deepcopy_VkVideoEncodeH265ProfileEXT(Allocator* alloc, VkStructureType rootType,
-                                          const VkVideoEncodeH265ProfileEXT* from,
-                                          VkVideoEncodeH265ProfileEXT* to) {
+void deepcopy_VkVideoEncodeH265ProfileInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoEncodeH265ProfileInfoEXT* from,
+                                              VkVideoEncodeH265ProfileInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -9920,11 +11023,9 @@ void deepcopy_VkVideoEncodeH265ProfileEXT(Allocator* alloc, VkStructureType root
     }
 }
 
-#endif
-#ifdef VK_EXT_video_decode_h264
-void deepcopy_VkVideoDecodeH264ProfileEXT(Allocator* alloc, VkStructureType rootType,
-                                          const VkVideoDecodeH264ProfileEXT* from,
-                                          VkVideoDecodeH264ProfileEXT* to) {
+void deepcopy_VkVideoEncodeH265RateControlInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                  const VkVideoEncodeH265RateControlInfoEXT* from,
+                                                  VkVideoEncodeH265RateControlInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -9944,98 +11045,26 @@ void deepcopy_VkVideoDecodeH264ProfileEXT(Allocator* alloc, VkStructureType root
     }
 }
 
-void deepcopy_VkVideoDecodeH264CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
-                                               const VkVideoDecodeH264CapabilitiesEXT* from,
-                                               VkVideoDecodeH264CapabilitiesEXT* to) {
+void deepcopy_VkVideoEncodeH265QpEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkVideoEncodeH265QpEXT* from,
+                                     VkVideoEncodeH265QpEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    deepcopy_VkOffset2D(alloc, rootType, &from->fieldOffsetGranularity,
-                        (VkOffset2D*)(&to->fieldOffsetGranularity));
-    deepcopy_VkExtensionProperties(alloc, rootType, &from->stdExtensionVersion,
-                                   (VkExtensionProperties*)(&to->stdExtensionVersion));
 }
 
-void deepcopy_VkVideoDecodeH264SessionCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType, const VkVideoDecodeH264SessionCreateInfoEXT* from,
-    VkVideoDecodeH264SessionCreateInfoEXT* to) {
+void deepcopy_VkVideoEncodeH265FrameSizeEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkVideoEncodeH265FrameSizeEXT* from,
+                                            VkVideoEncodeH265FrameSizeEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    to->pStdExtensionVersion = nullptr;
-    if (from->pStdExtensionVersion) {
-        to->pStdExtensionVersion =
-            (VkExtensionProperties*)alloc->alloc(sizeof(const VkExtensionProperties));
-        deepcopy_VkExtensionProperties(alloc, rootType, from->pStdExtensionVersion,
-                                       (VkExtensionProperties*)(to->pStdExtensionVersion));
-    }
-}
-
-void deepcopy_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkVideoDecodeH264SessionParametersAddInfoEXT* from,
-    VkVideoDecodeH264SessionParametersAddInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    to->pSpsStd = nullptr;
-    if (from->pSpsStd) {
-        to->pSpsStd = (StdVideoH264SequenceParameterSet*)alloc->dupArray(
-            from->pSpsStd, from->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
-    }
-    to->pPpsStd = nullptr;
-    if (from->pPpsStd) {
-        to->pPpsStd = (StdVideoH264PictureParameterSet*)alloc->dupArray(
-            from->pPpsStd, from->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
-    }
 }
 
-void deepcopy_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+void deepcopy_VkVideoEncodeH265RateControlLayerInfoEXT(
     Allocator* alloc, VkStructureType rootType,
-    const VkVideoDecodeH264SessionParametersCreateInfoEXT* from,
-    VkVideoDecodeH264SessionParametersCreateInfoEXT* to) {
+    const VkVideoEncodeH265RateControlLayerInfoEXT* from,
+    VkVideoEncodeH265RateControlLayerInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -10053,100 +11082,14 @@ void deepcopy_VkVideoDecodeH264SessionParametersCreateInfoEXT(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    to->pParametersAddInfo = nullptr;
-    if (from->pParametersAddInfo) {
-        to->pParametersAddInfo = (VkVideoDecodeH264SessionParametersAddInfoEXT*)alloc->alloc(
-            sizeof(const VkVideoDecodeH264SessionParametersAddInfoEXT));
-        deepcopy_VkVideoDecodeH264SessionParametersAddInfoEXT(
-            alloc, rootType, from->pParametersAddInfo,
-            (VkVideoDecodeH264SessionParametersAddInfoEXT*)(to->pParametersAddInfo));
-    }
-}
-
-void deepcopy_VkVideoDecodeH264PictureInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                              const VkVideoDecodeH264PictureInfoEXT* from,
-                                              VkVideoDecodeH264PictureInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    to->pStdPictureInfo = nullptr;
-    if (from->pStdPictureInfo) {
-        to->pStdPictureInfo = (StdVideoDecodeH264PictureInfo*)alloc->dupArray(
-            from->pStdPictureInfo, sizeof(const StdVideoDecodeH264PictureInfo));
-    }
-    to->pSlicesDataOffsets = nullptr;
-    if (from->pSlicesDataOffsets) {
-        to->pSlicesDataOffsets = (uint32_t*)alloc->dupArray(
-            from->pSlicesDataOffsets, from->slicesCount * sizeof(const uint32_t));
-    }
-}
-
-void deepcopy_VkVideoDecodeH264MvcEXT(Allocator* alloc, VkStructureType rootType,
-                                      const VkVideoDecodeH264MvcEXT* from,
-                                      VkVideoDecodeH264MvcEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    to->pStdMvc = nullptr;
-    if (from->pStdMvc) {
-        to->pStdMvc = (StdVideoDecodeH264Mvc*)alloc->dupArray(from->pStdMvc,
-                                                              sizeof(const StdVideoDecodeH264Mvc));
-    }
-}
-
-void deepcopy_VkVideoDecodeH264DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                              const VkVideoDecodeH264DpbSlotInfoEXT* from,
-                                              VkVideoDecodeH264DpbSlotInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    to->pStdReferenceInfo = nullptr;
-    if (from->pStdReferenceInfo) {
-        to->pStdReferenceInfo = (StdVideoDecodeH264ReferenceInfo*)alloc->dupArray(
-            from->pStdReferenceInfo, sizeof(const StdVideoDecodeH264ReferenceInfo));
-    }
+    deepcopy_VkVideoEncodeH265QpEXT(alloc, rootType, &from->initialRcQp,
+                                    (VkVideoEncodeH265QpEXT*)(&to->initialRcQp));
+    deepcopy_VkVideoEncodeH265QpEXT(alloc, rootType, &from->minQp,
+                                    (VkVideoEncodeH265QpEXT*)(&to->minQp));
+    deepcopy_VkVideoEncodeH265QpEXT(alloc, rootType, &from->maxQp,
+                                    (VkVideoEncodeH265QpEXT*)(&to->maxQp));
+    deepcopy_VkVideoEncodeH265FrameSizeEXT(alloc, rootType, &from->maxFrameSize,
+                                           (VkVideoEncodeH265FrameSizeEXT*)(&to->maxFrameSize));
 }
 
 #endif
@@ -10468,10 +11411,33 @@ void deepcopy_VkViSurfaceCreateInfoNN(Allocator* alloc, VkStructureType rootType
 #ifdef VK_EXT_shader_subgroup_vote
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
-void deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* from,
-    VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* to) {
+#endif
+#ifdef VK_EXT_astc_decode_mode
+void deepcopy_VkImageViewASTCDecodeModeEXT(Allocator* alloc, VkStructureType rootType,
+                                           const VkImageViewASTCDecodeModeEXT* from,
+                                           VkImageViewASTCDecodeModeEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceASTCDecodeFeaturesEXT* from,
+    VkPhysicalDeviceASTCDecodeFeaturesEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -10492,10 +11458,11 @@ void deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
 }
 
 #endif
-#ifdef VK_EXT_astc_decode_mode
-void deepcopy_VkImageViewASTCDecodeModeEXT(Allocator* alloc, VkStructureType rootType,
-                                           const VkImageViewASTCDecodeModeEXT* from,
-                                           VkImageViewASTCDecodeModeEXT* to) {
+#ifdef VK_EXT_pipeline_robustness
+void deepcopy_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* from,
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -10515,9 +11482,32 @@ void deepcopy_VkImageViewASTCDecodeModeEXT(Allocator* alloc, VkStructureType roo
     }
 }
 
-void deepcopy_VkPhysicalDeviceASTCDecodeFeaturesEXT(
-    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceASTCDecodeFeaturesEXT* from,
-    VkPhysicalDeviceASTCDecodeFeaturesEXT* to) {
+void deepcopy_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* from,
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPipelineRobustnessCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                const VkPipelineRobustnessCreateInfoEXT* from,
+                                                VkPipelineRobustnessCreateInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -11155,8 +12145,6 @@ void deepcopy_VkMacOSSurfaceCreateInfoMVK(Allocator* alloc, VkStructureType root
 }
 
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -11245,8 +12233,8 @@ void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(Allocator* alloc, VkStructure
     if (from) {
         to->pQueueLabels = nullptr;
         if (from->pQueueLabels) {
-            to->pQueueLabels = (VkDebugUtilsLabelEXT*)alloc->alloc(from->queueLabelCount *
-                                                                   sizeof(VkDebugUtilsLabelEXT));
+            to->pQueueLabels = (VkDebugUtilsLabelEXT*)alloc->alloc(
+                from->queueLabelCount * sizeof(const VkDebugUtilsLabelEXT));
             to->queueLabelCount = from->queueLabelCount;
             for (uint32_t i = 0; i < (uint32_t)from->queueLabelCount; ++i) {
                 deepcopy_VkDebugUtilsLabelEXT(alloc, rootType, from->pQueueLabels + i,
@@ -11257,8 +12245,8 @@ void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(Allocator* alloc, VkStructure
     if (from) {
         to->pCmdBufLabels = nullptr;
         if (from->pCmdBufLabels) {
-            to->pCmdBufLabels = (VkDebugUtilsLabelEXT*)alloc->alloc(from->cmdBufLabelCount *
-                                                                    sizeof(VkDebugUtilsLabelEXT));
+            to->pCmdBufLabels = (VkDebugUtilsLabelEXT*)alloc->alloc(
+                from->cmdBufLabelCount * sizeof(const VkDebugUtilsLabelEXT));
             to->cmdBufLabelCount = from->cmdBufLabelCount;
             for (uint32_t i = 0; i < (uint32_t)from->cmdBufLabelCount; ++i) {
                 deepcopy_VkDebugUtilsLabelEXT(alloc, rootType, from->pCmdBufLabels + i,
@@ -11270,7 +12258,7 @@ void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(Allocator* alloc, VkStructure
         to->pObjects = nullptr;
         if (from->pObjects) {
             to->pObjects = (VkDebugUtilsObjectNameInfoEXT*)alloc->alloc(
-                from->objectCount * sizeof(VkDebugUtilsObjectNameInfoEXT));
+                from->objectCount * sizeof(const VkDebugUtilsObjectNameInfoEXT));
             to->objectCount = from->objectCount;
             for (uint32_t i = 0; i < (uint32_t)from->objectCount; ++i) {
                 deepcopy_VkDebugUtilsObjectNameInfoEXT(
@@ -11512,102 +12500,6 @@ void deepcopy_VkAndroidHardwareBufferFormatProperties2ANDROID(
 #ifdef VK_AMD_shader_fragment_mask
 #endif
 #ifdef VK_EXT_inline_uniform_block
-void deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* from,
-    VkPhysicalDeviceInlineUniformBlockFeaturesEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-}
-
-void deepcopy_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* from,
-    VkPhysicalDeviceInlineUniformBlockPropertiesEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-}
-
-void deepcopy_VkWriteDescriptorSetInlineUniformBlockEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkWriteDescriptorSetInlineUniformBlockEXT* from,
-    VkWriteDescriptorSetInlineUniformBlockEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    to->pData = nullptr;
-    if (from->pData) {
-        to->pData = (void*)alloc->dupArray(from->pData, from->dataSize * sizeof(const uint8_t));
-    }
-}
-
-void deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* from,
-    VkDescriptorPoolInlineUniformBlockCreateInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-}
-
 #endif
 #ifdef VK_EXT_shader_stencil_export
 #endif
@@ -12831,29 +13723,6 @@ void deepcopy_VkFilterCubicImageViewImageFormatPropertiesEXT(
 #ifdef VK_QCOM_render_pass_shader_resolve
 #endif
 #ifdef VK_EXT_global_priority
-void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkDeviceQueueGlobalPriorityCreateInfoEXT* from,
-    VkDeviceQueueGlobalPriorityCreateInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-}
-
 #endif
 #ifdef VK_EXT_external_memory_host
 void deepcopy_VkImportMemoryHostPointerInfoEXT(Allocator* alloc, VkStructureType rootType,
@@ -13002,206 +13871,6 @@ void deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(
 }
 
 #endif
-#ifdef VK_EXT_video_decode_h265
-void deepcopy_VkVideoDecodeH265ProfileEXT(Allocator* alloc, VkStructureType rootType,
-                                          const VkVideoDecodeH265ProfileEXT* from,
-                                          VkVideoDecodeH265ProfileEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-}
-
-void deepcopy_VkVideoDecodeH265CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
-                                               const VkVideoDecodeH265CapabilitiesEXT* from,
-                                               VkVideoDecodeH265CapabilitiesEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    deepcopy_VkExtensionProperties(alloc, rootType, &from->stdExtensionVersion,
-                                   (VkExtensionProperties*)(&to->stdExtensionVersion));
-}
-
-void deepcopy_VkVideoDecodeH265SessionCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType, const VkVideoDecodeH265SessionCreateInfoEXT* from,
-    VkVideoDecodeH265SessionCreateInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    to->pStdExtensionVersion = nullptr;
-    if (from->pStdExtensionVersion) {
-        to->pStdExtensionVersion =
-            (VkExtensionProperties*)alloc->alloc(sizeof(const VkExtensionProperties));
-        deepcopy_VkExtensionProperties(alloc, rootType, from->pStdExtensionVersion,
-                                       (VkExtensionProperties*)(to->pStdExtensionVersion));
-    }
-}
-
-void deepcopy_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkVideoDecodeH265SessionParametersAddInfoEXT* from,
-    VkVideoDecodeH265SessionParametersAddInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    to->pSpsStd = nullptr;
-    if (from->pSpsStd) {
-        to->pSpsStd = (StdVideoH265SequenceParameterSet*)alloc->dupArray(
-            from->pSpsStd, from->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
-    }
-    to->pPpsStd = nullptr;
-    if (from->pPpsStd) {
-        to->pPpsStd = (StdVideoH265PictureParameterSet*)alloc->dupArray(
-            from->pPpsStd, from->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
-    }
-}
-
-void deepcopy_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkVideoDecodeH265SessionParametersCreateInfoEXT* from,
-    VkVideoDecodeH265SessionParametersCreateInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    to->pParametersAddInfo = nullptr;
-    if (from->pParametersAddInfo) {
-        to->pParametersAddInfo = (VkVideoDecodeH265SessionParametersAddInfoEXT*)alloc->alloc(
-            sizeof(const VkVideoDecodeH265SessionParametersAddInfoEXT));
-        deepcopy_VkVideoDecodeH265SessionParametersAddInfoEXT(
-            alloc, rootType, from->pParametersAddInfo,
-            (VkVideoDecodeH265SessionParametersAddInfoEXT*)(to->pParametersAddInfo));
-    }
-}
-
-void deepcopy_VkVideoDecodeH265PictureInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                              const VkVideoDecodeH265PictureInfoEXT* from,
-                                              VkVideoDecodeH265PictureInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    to->pStdPictureInfo = nullptr;
-    if (from->pStdPictureInfo) {
-        to->pStdPictureInfo = (StdVideoDecodeH265PictureInfo*)alloc->dupArray(
-            from->pStdPictureInfo, sizeof(StdVideoDecodeH265PictureInfo));
-    }
-    to->pSlicesDataOffsets = nullptr;
-    if (from->pSlicesDataOffsets) {
-        to->pSlicesDataOffsets = (uint32_t*)alloc->dupArray(
-            from->pSlicesDataOffsets, from->slicesCount * sizeof(const uint32_t));
-    }
-}
-
-void deepcopy_VkVideoDecodeH265DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                              const VkVideoDecodeH265DpbSlotInfoEXT* from,
-                                              VkVideoDecodeH265DpbSlotInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    to->pStdReferenceInfo = nullptr;
-    if (from->pStdReferenceInfo) {
-        to->pStdReferenceInfo = (StdVideoDecodeH265ReferenceInfo*)alloc->dupArray(
-            from->pStdReferenceInfo, sizeof(const StdVideoDecodeH265ReferenceInfo));
-    }
-}
-
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 void deepcopy_VkDeviceMemoryOverallocationCreateInfoAMD(
     Allocator* alloc, VkStructureType rootType,
@@ -13346,57 +14015,6 @@ void deepcopy_VkPresentFrameTokenGGP(Allocator* alloc, VkStructureType rootType,
 
 #endif
 #ifdef VK_EXT_pipeline_creation_feedback
-void deepcopy_VkPipelineCreationFeedbackEXT(Allocator* alloc, VkStructureType rootType,
-                                            const VkPipelineCreationFeedbackEXT* from,
-                                            VkPipelineCreationFeedbackEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-}
-
-void deepcopy_VkPipelineCreationFeedbackCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType, const VkPipelineCreationFeedbackCreateInfoEXT* from,
-    VkPipelineCreationFeedbackCreateInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    to->pPipelineCreationFeedback = nullptr;
-    if (from->pPipelineCreationFeedback) {
-        to->pPipelineCreationFeedback =
-            (VkPipelineCreationFeedbackEXT*)alloc->alloc(sizeof(VkPipelineCreationFeedbackEXT));
-        deepcopy_VkPipelineCreationFeedbackEXT(
-            alloc, rootType, from->pPipelineCreationFeedback,
-            (VkPipelineCreationFeedbackEXT*)(to->pPipelineCreationFeedback));
-    }
-    if (from) {
-        to->pPipelineStageCreationFeedbacks = nullptr;
-        if (from->pPipelineStageCreationFeedbacks) {
-            to->pPipelineStageCreationFeedbacks = (VkPipelineCreationFeedbackEXT*)alloc->alloc(
-                from->pipelineStageCreationFeedbackCount * sizeof(VkPipelineCreationFeedbackEXT));
-            to->pipelineStageCreationFeedbackCount = from->pipelineStageCreationFeedbackCount;
-            for (uint32_t i = 0; i < (uint32_t)from->pipelineStageCreationFeedbackCount; ++i) {
-                deepcopy_VkPipelineCreationFeedbackEXT(
-                    alloc, rootType, from->pPipelineStageCreationFeedbacks + i,
-                    (VkPipelineCreationFeedbackEXT*)(to->pPipelineStageCreationFeedbacks + i));
-            }
-        }
-    }
-}
-
 #endif
 #ifdef VK_NV_shader_subgroup_partitioned
 #endif
@@ -13482,29 +14100,6 @@ void deepcopy_VkDrawMeshTasksIndirectCommandNV(Allocator* alloc, VkStructureType
 
 #endif
 #ifdef VK_NV_fragment_shader_barycentric
-void deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* from,
-    VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-}
-
 #endif
 #ifdef VK_NV_shader_image_footprint
 void deepcopy_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -14035,75 +14630,6 @@ void deepcopy_VkRenderPassFragmentDensityMapCreateInfoEXT(
 #ifdef VK_GOOGLE_decorate_string
 #endif
 #ifdef VK_EXT_subgroup_size_control
-void deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* from,
-    VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-}
-
-void deepcopy_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* from,
-    VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-}
-
-void deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* from,
-    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-}
-
 #endif
 #ifdef VK_AMD_shader_core_properties2
 void deepcopy_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -14327,32 +14853,6 @@ void deepcopy_VkBufferDeviceAddressCreateInfoEXT(Allocator* alloc, VkStructureTy
 
 #endif
 #ifdef VK_EXT_tooling_info
-void deepcopy_VkPhysicalDeviceToolPropertiesEXT(Allocator* alloc, VkStructureType rootType,
-                                                const VkPhysicalDeviceToolPropertiesEXT* from,
-                                                VkPhysicalDeviceToolPropertiesEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-    memcpy(to->name, from->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-    memcpy(to->version, from->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    memcpy(to->layer, from->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-}
-
 #endif
 #ifdef VK_EXT_separate_stencil_usage
 #endif
@@ -14920,11 +15420,110 @@ void deepcopy_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
 }
 
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-void deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+void deepcopy_VkSurfacePresentModeEXT(Allocator* alloc, VkStructureType rootType,
+                                      const VkSurfacePresentModeEXT* from,
+                                      VkSurfacePresentModeEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkSurfacePresentScalingCapabilitiesEXT(
+    Allocator* alloc, VkStructureType rootType, const VkSurfacePresentScalingCapabilitiesEXT* from,
+    VkSurfacePresentScalingCapabilitiesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkExtent2D(alloc, rootType, &from->minScaledImageExtent,
+                        (VkExtent2D*)(&to->minScaledImageExtent));
+    deepcopy_VkExtent2D(alloc, rootType, &from->maxScaledImageExtent,
+                        (VkExtent2D*)(&to->maxScaledImageExtent));
+}
+
+void deepcopy_VkSurfacePresentModeCompatibilityEXT(Allocator* alloc, VkStructureType rootType,
+                                                   const VkSurfacePresentModeCompatibilityEXT* from,
+                                                   VkSurfacePresentModeCompatibilityEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pPresentModes = nullptr;
+    if (from->pPresentModes) {
+        to->pPresentModes = (VkPresentModeKHR*)alloc->dupArray(
+            from->pPresentModes, from->presentModeCount * sizeof(VkPresentModeKHR));
+    }
+}
+
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+void deepcopy_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* from,
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* to) {
+    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* from,
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkSwapchainPresentFenceInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                             const VkSwapchainPresentFenceInfoEXT* from,
+                                             VkSwapchainPresentFenceInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -14942,9 +15541,119 @@ void deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
+    to->pFences = nullptr;
+    if (from->pFences) {
+        to->pFences =
+            (VkFence*)alloc->dupArray(from->pFences, from->swapchainCount * sizeof(const VkFence));
+    }
+}
+
+void deepcopy_VkSwapchainPresentModesCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                   const VkSwapchainPresentModesCreateInfoEXT* from,
+                                                   VkSwapchainPresentModesCreateInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pPresentModes = nullptr;
+    if (from->pPresentModes) {
+        to->pPresentModes = (VkPresentModeKHR*)alloc->dupArray(
+            from->pPresentModes, from->presentModeCount * sizeof(const VkPresentModeKHR));
+    }
+}
+
+void deepcopy_VkSwapchainPresentModeInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkSwapchainPresentModeInfoEXT* from,
+                                            VkSwapchainPresentModeInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pPresentModes = nullptr;
+    if (from->pPresentModes) {
+        to->pPresentModes = (VkPresentModeKHR*)alloc->dupArray(
+            from->pPresentModes, from->swapchainCount * sizeof(const VkPresentModeKHR));
+    }
+}
+
+void deepcopy_VkSwapchainPresentScalingCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType, const VkSwapchainPresentScalingCreateInfoEXT* from,
+    VkSwapchainPresentScalingCreateInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkReleaseSwapchainImagesInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkReleaseSwapchainImagesInfoEXT* from,
+                                              VkReleaseSwapchainImagesInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pImageIndices = nullptr;
+    if (from->pImageIndices) {
+        to->pImageIndices = (uint32_t*)alloc->dupArray(
+            from->pImageIndices, from->imageIndexCount * sizeof(const uint32_t));
+    }
 }
 
 #endif
+#ifdef VK_EXT_shader_demote_to_helper_invocation
+#endif
 #ifdef VK_NV_device_generated_commands
 void deepcopy_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
     Allocator* alloc, VkStructureType rootType,
@@ -15333,29 +16042,6 @@ void deepcopy_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
     }
 }
 
-void deepcopy_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* from,
-    VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* to) {
-    (void)alloc;
-    (void)rootType;
-    *to = *from;
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = from->sType;
-    }
-    const void* from_pNext = from;
-    size_t pNext_size = 0u;
-    while (!pNext_size && from_pNext) {
-        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
-        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
-    }
-    to->pNext = nullptr;
-    if (pNext_size) {
-        to->pNext = (void*)alloc->alloc(pNext_size);
-        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
-    }
-}
-
 #endif
 #ifdef VK_QCOM_render_pass_transform
 void deepcopy_VkRenderPassTransformBeginInfoQCOM(Allocator* alloc, VkStructureType rootType,
@@ -15601,10 +16287,11 @@ void deepcopy_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
-#ifdef VK_EXT_private_data
-void deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT(
-    Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePrivateDataFeaturesEXT* from,
-    VkPhysicalDevicePrivateDataFeaturesEXT* to) {
+#ifdef VK_NV_present_barrier
+void deepcopy_VkPhysicalDevicePresentBarrierFeaturesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePresentBarrierFeaturesNV* from,
+    VkPhysicalDevicePresentBarrierFeaturesNV* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -15624,9 +16311,9 @@ void deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT(
     }
 }
 
-void deepcopy_VkDevicePrivateDataCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                               const VkDevicePrivateDataCreateInfoEXT* from,
-                                               VkDevicePrivateDataCreateInfoEXT* to) {
+void deepcopy_VkSurfaceCapabilitiesPresentBarrierNV(
+    Allocator* alloc, VkStructureType rootType, const VkSurfaceCapabilitiesPresentBarrierNV* from,
+    VkSurfaceCapabilitiesPresentBarrierNV* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -15646,9 +16333,9 @@ void deepcopy_VkDevicePrivateDataCreateInfoEXT(Allocator* alloc, VkStructureType
     }
 }
 
-void deepcopy_VkPrivateDataSlotCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                             const VkPrivateDataSlotCreateInfoEXT* from,
-                                             VkPrivateDataSlotCreateInfoEXT* to) {
+void deepcopy_VkSwapchainPresentBarrierCreateInfoNV(
+    Allocator* alloc, VkStructureType rootType, const VkSwapchainPresentBarrierCreateInfoNV* from,
+    VkSwapchainPresentBarrierCreateInfoNV* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -15669,11 +16356,37 @@ void deepcopy_VkPrivateDataSlotCreateInfoEXT(Allocator* alloc, VkStructureType r
 }
 
 #endif
+#ifdef VK_EXT_private_data
+#endif
 #ifdef VK_EXT_pipeline_creation_cache_control
-void deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+#endif
+#ifdef VK_NV_device_diagnostics_config
+void deepcopy_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
     Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* from,
-    VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* to) {
+    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* from,
+    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDeviceDiagnosticsConfigCreateInfoNV(
+    Allocator* alloc, VkStructureType rootType, const VkDeviceDiagnosticsConfigCreateInfoNV* from,
+    VkDeviceDiagnosticsConfigCreateInfoNV* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -15694,11 +16407,308 @@ void deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
 }
 
 #endif
-#ifdef VK_NV_device_diagnostics_config
-void deepcopy_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+#ifdef VK_QCOM_render_pass_store_ops
+#endif
+#ifdef VK_NV_low_latency
+void deepcopy_VkQueryLowLatencySupportNV(Allocator* alloc, VkStructureType rootType,
+                                         const VkQueryLowLatencySupportNV* from,
+                                         VkQueryLowLatencySupportNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pQueriedLowLatencyData = nullptr;
+    if (from->pQueriedLowLatencyData) {
+        to->pQueriedLowLatencyData =
+            (void*)alloc->dupArray(from->pQueriedLowLatencyData, sizeof(uint8_t));
+    }
+}
+
+#endif
+#ifdef VK_EXT_metal_objects
+void deepcopy_VkExportMetalObjectCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                               const VkExportMetalObjectCreateInfoEXT* from,
+                                               VkExportMetalObjectCreateInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportMetalObjectsInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                          const VkExportMetalObjectsInfoEXT* from,
+                                          VkExportMetalObjectsInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportMetalDeviceInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkExportMetalDeviceInfoEXT* from,
+                                         VkExportMetalDeviceInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportMetalCommandQueueInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                               const VkExportMetalCommandQueueInfoEXT* from,
+                                               VkExportMetalCommandQueueInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportMetalBufferInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkExportMetalBufferInfoEXT* from,
+                                         VkExportMetalBufferInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImportMetalBufferInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkImportMetalBufferInfoEXT* from,
+                                         VkImportMetalBufferInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportMetalTextureInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                          const VkExportMetalTextureInfoEXT* from,
+                                          VkExportMetalTextureInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImportMetalTextureInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                          const VkImportMetalTextureInfoEXT* from,
+                                          VkImportMetalTextureInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportMetalIOSurfaceInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkExportMetalIOSurfaceInfoEXT* from,
+                                            VkExportMetalIOSurfaceInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImportMetalIOSurfaceInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkImportMetalIOSurfaceInfoEXT* from,
+                                            VkImportMetalIOSurfaceInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkExportMetalSharedEventInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkExportMetalSharedEventInfoEXT* from,
+                                              VkExportMetalSharedEventInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImportMetalSharedEventInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkImportMetalSharedEventInfoEXT* from,
+                                              VkImportMetalSharedEventInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void deepcopy_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
     Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* from,
-    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* to) {
+    const VkPhysicalDeviceDescriptorBufferPropertiesEXT* from,
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -15718,9 +16728,329 @@ void deepcopy_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
     }
 }
 
-void deepcopy_VkDeviceDiagnosticsConfigCreateInfoNV(
-    Allocator* alloc, VkStructureType rootType, const VkDeviceDiagnosticsConfigCreateInfoNV* from,
-    VkDeviceDiagnosticsConfigCreateInfoNV* to) {
+void deepcopy_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* from,
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorBufferFeaturesEXT* from,
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDescriptorAddressInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkDescriptorAddressInfoEXT* from,
+                                         VkDescriptorAddressInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDescriptorBufferBindingInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                               const VkDescriptorBufferBindingInfoEXT* from,
+                                               VkDescriptorBufferBindingInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* from,
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDescriptorDataEXT(Allocator* alloc, VkStructureType rootType,
+                                  const VkDescriptorDataEXT* from, VkDescriptorDataEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    to->pSampler = nullptr;
+    if (from->pSampler) {
+        to->pSampler = (VkSampler*)alloc->dupArray(from->pSampler, sizeof(const VkSampler));
+    }
+    to->pCombinedImageSampler = nullptr;
+    if (from->pCombinedImageSampler) {
+        to->pCombinedImageSampler =
+            (VkDescriptorImageInfo*)alloc->alloc(sizeof(const VkDescriptorImageInfo));
+        deepcopy_VkDescriptorImageInfo(alloc, rootType, from->pCombinedImageSampler,
+                                       (VkDescriptorImageInfo*)(to->pCombinedImageSampler));
+    }
+    to->pInputAttachmentImage = nullptr;
+    if (from->pInputAttachmentImage) {
+        to->pInputAttachmentImage =
+            (VkDescriptorImageInfo*)alloc->alloc(sizeof(const VkDescriptorImageInfo));
+        deepcopy_VkDescriptorImageInfo(alloc, rootType, from->pInputAttachmentImage,
+                                       (VkDescriptorImageInfo*)(to->pInputAttachmentImage));
+    }
+    to->pSampledImage = nullptr;
+    if (from->pSampledImage) {
+        to->pSampledImage =
+            (VkDescriptorImageInfo*)alloc->alloc(sizeof(const VkDescriptorImageInfo));
+        deepcopy_VkDescriptorImageInfo(alloc, rootType, from->pSampledImage,
+                                       (VkDescriptorImageInfo*)(to->pSampledImage));
+    }
+    to->pStorageImage = nullptr;
+    if (from->pStorageImage) {
+        to->pStorageImage =
+            (VkDescriptorImageInfo*)alloc->alloc(sizeof(const VkDescriptorImageInfo));
+        deepcopy_VkDescriptorImageInfo(alloc, rootType, from->pStorageImage,
+                                       (VkDescriptorImageInfo*)(to->pStorageImage));
+    }
+    to->pUniformTexelBuffer = nullptr;
+    if (from->pUniformTexelBuffer) {
+        to->pUniformTexelBuffer =
+            (VkDescriptorAddressInfoEXT*)alloc->alloc(sizeof(const VkDescriptorAddressInfoEXT));
+        deepcopy_VkDescriptorAddressInfoEXT(alloc, rootType, from->pUniformTexelBuffer,
+                                            (VkDescriptorAddressInfoEXT*)(to->pUniformTexelBuffer));
+    }
+    to->pStorageTexelBuffer = nullptr;
+    if (from->pStorageTexelBuffer) {
+        to->pStorageTexelBuffer =
+            (VkDescriptorAddressInfoEXT*)alloc->alloc(sizeof(const VkDescriptorAddressInfoEXT));
+        deepcopy_VkDescriptorAddressInfoEXT(alloc, rootType, from->pStorageTexelBuffer,
+                                            (VkDescriptorAddressInfoEXT*)(to->pStorageTexelBuffer));
+    }
+    to->pUniformBuffer = nullptr;
+    if (from->pUniformBuffer) {
+        to->pUniformBuffer =
+            (VkDescriptorAddressInfoEXT*)alloc->alloc(sizeof(const VkDescriptorAddressInfoEXT));
+        deepcopy_VkDescriptorAddressInfoEXT(alloc, rootType, from->pUniformBuffer,
+                                            (VkDescriptorAddressInfoEXT*)(to->pUniformBuffer));
+    }
+    to->pStorageBuffer = nullptr;
+    if (from->pStorageBuffer) {
+        to->pStorageBuffer =
+            (VkDescriptorAddressInfoEXT*)alloc->alloc(sizeof(const VkDescriptorAddressInfoEXT));
+        deepcopy_VkDescriptorAddressInfoEXT(alloc, rootType, from->pStorageBuffer,
+                                            (VkDescriptorAddressInfoEXT*)(to->pStorageBuffer));
+    }
+}
+
+void deepcopy_VkDescriptorGetInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkDescriptorGetInfoEXT* from,
+                                     VkDescriptorGetInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkDescriptorDataEXT(alloc, rootType, &from->data, (VkDescriptorDataEXT*)(&to->data));
+}
+
+void deepcopy_VkBufferCaptureDescriptorDataInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                   const VkBufferCaptureDescriptorDataInfoEXT* from,
+                                                   VkBufferCaptureDescriptorDataInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImageCaptureDescriptorDataInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                  const VkImageCaptureDescriptorDataInfoEXT* from,
+                                                  VkImageCaptureDescriptorDataInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImageViewCaptureDescriptorDataInfoEXT(
+    Allocator* alloc, VkStructureType rootType, const VkImageViewCaptureDescriptorDataInfoEXT* from,
+    VkImageViewCaptureDescriptorDataInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkSamplerCaptureDescriptorDataInfoEXT(
+    Allocator* alloc, VkStructureType rootType, const VkSamplerCaptureDescriptorDataInfoEXT* from,
+    VkSamplerCaptureDescriptorDataInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkOpaqueCaptureDescriptorDataCreateInfoEXT* from,
+    VkOpaqueCaptureDescriptorDataCreateInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->opaqueCaptureDescriptorData = nullptr;
+    if (from->opaqueCaptureDescriptorData) {
+        to->opaqueCaptureDescriptorData =
+            (void*)alloc->dupArray(from->opaqueCaptureDescriptorData, sizeof(const uint8_t));
+    }
+}
+
+void deepcopy_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* from,
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -15741,7 +17071,100 @@ void deepcopy_VkDeviceDiagnosticsConfigCreateInfoNV(
 }
 
 #endif
-#ifdef VK_QCOM_render_pass_store_ops
+#ifdef VK_EXT_graphics_pipeline_library
+void deepcopy_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* from,
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* from,
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkGraphicsPipelineLibraryCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType, const VkGraphicsPipelineLibraryCreateInfoEXT* from,
+    VkGraphicsPipelineLibraryCreateInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+void deepcopy_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* from,
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
 #endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -16056,10 +17479,135 @@ void deepcopy_VkCopyCommandTransformInfoQCOM(Allocator* alloc, VkStructureType r
 
 #endif
 #ifdef VK_EXT_image_robustness
-void deepcopy_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+#endif
+#ifdef VK_EXT_image_compression_control
+void deepcopy_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceImageRobustnessFeaturesEXT* from,
-    VkPhysicalDeviceImageRobustnessFeaturesEXT* to) {
+    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* from,
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImageCompressionControlEXT(Allocator* alloc, VkStructureType rootType,
+                                           const VkImageCompressionControlEXT* from,
+                                           VkImageCompressionControlEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pFixedRateFlags = nullptr;
+    if (from->pFixedRateFlags) {
+        to->pFixedRateFlags = (VkImageCompressionFixedRateFlagsEXT*)alloc->dupArray(
+            from->pFixedRateFlags,
+            from->compressionControlPlaneCount * sizeof(VkImageCompressionFixedRateFlagsEXT));
+    }
+}
+
+void deepcopy_VkSubresourceLayout2EXT(Allocator* alloc, VkStructureType rootType,
+                                      const VkSubresourceLayout2EXT* from,
+                                      VkSubresourceLayout2EXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkSubresourceLayout(alloc, rootType, &from->subresourceLayout,
+                                 (VkSubresourceLayout*)(&to->subresourceLayout));
+}
+
+void deepcopy_VkImageSubresource2EXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkImageSubresource2EXT* from,
+                                     VkImageSubresource2EXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkImageSubresource(alloc, rootType, &from->imageSubresource,
+                                (VkImageSubresource*)(&to->imageSubresource));
+}
+
+void deepcopy_VkImageCompressionPropertiesEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkImageCompressionPropertiesEXT* from,
+                                              VkImageCompressionPropertiesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+void deepcopy_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* from,
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -16104,6 +17652,144 @@ void deepcopy_VkPhysicalDevice4444FormatsFeaturesEXT(
 }
 
 #endif
+#ifdef VK_EXT_device_fault
+void deepcopy_VkPhysicalDeviceFaultFeaturesEXT(Allocator* alloc, VkStructureType rootType,
+                                               const VkPhysicalDeviceFaultFeaturesEXT* from,
+                                               VkPhysicalDeviceFaultFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDeviceFaultCountsEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkDeviceFaultCountsEXT* from,
+                                     VkDeviceFaultCountsEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDeviceFaultAddressInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                          const VkDeviceFaultAddressInfoEXT* from,
+                                          VkDeviceFaultAddressInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+}
+
+void deepcopy_VkDeviceFaultVendorInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkDeviceFaultVendorInfoEXT* from,
+                                         VkDeviceFaultVendorInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+}
+
+void deepcopy_VkDeviceFaultInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                   const VkDeviceFaultInfoEXT* from, VkDeviceFaultInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    to->pAddressInfos = nullptr;
+    if (from->pAddressInfos) {
+        to->pAddressInfos =
+            (VkDeviceFaultAddressInfoEXT*)alloc->alloc(sizeof(VkDeviceFaultAddressInfoEXT));
+        deepcopy_VkDeviceFaultAddressInfoEXT(alloc, rootType, from->pAddressInfos,
+                                             (VkDeviceFaultAddressInfoEXT*)(to->pAddressInfos));
+    }
+    to->pVendorInfos = nullptr;
+    if (from->pVendorInfos) {
+        to->pVendorInfos =
+            (VkDeviceFaultVendorInfoEXT*)alloc->alloc(sizeof(VkDeviceFaultVendorInfoEXT));
+        deepcopy_VkDeviceFaultVendorInfoEXT(alloc, rootType, from->pVendorInfos,
+                                            (VkDeviceFaultVendorInfoEXT*)(to->pVendorInfos));
+    }
+    to->pVendorBinaryData = nullptr;
+    if (from->pVendorBinaryData) {
+        to->pVendorBinaryData = (void*)alloc->dupArray(from->pVendorBinaryData, sizeof(uint8_t));
+    }
+}
+
+void deepcopy_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkDeviceFaultVendorBinaryHeaderVersionOneEXT* from,
+    VkDeviceFaultVendorBinaryHeaderVersionOneEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    memcpy(to->pipelineCacheUUID, from->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
+}
+
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+void deepcopy_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* from,
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 void deepcopy_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
@@ -16164,10 +17850,10 @@ void deepcopy_VkDirectFBSurfaceCreateInfoEXT(Allocator* alloc, VkStructureType r
 
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-void deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+void deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* from,
-    VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* to) {
+    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* from,
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -16187,9 +17873,9 @@ void deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
     }
 }
 
-void deepcopy_VkMutableDescriptorTypeListVALVE(Allocator* alloc, VkStructureType rootType,
-                                               const VkMutableDescriptorTypeListVALVE* from,
-                                               VkMutableDescriptorTypeListVALVE* to) {
+void deepcopy_VkMutableDescriptorTypeListEXT(Allocator* alloc, VkStructureType rootType,
+                                             const VkMutableDescriptorTypeListEXT* from,
+                                             VkMutableDescriptorTypeListEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -16200,9 +17886,9 @@ void deepcopy_VkMutableDescriptorTypeListVALVE(Allocator* alloc, VkStructureType
     }
 }
 
-void deepcopy_VkMutableDescriptorTypeCreateInfoVALVE(
-    Allocator* alloc, VkStructureType rootType, const VkMutableDescriptorTypeCreateInfoVALVE* from,
-    VkMutableDescriptorTypeCreateInfoVALVE* to) {
+void deepcopy_VkMutableDescriptorTypeCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                   const VkMutableDescriptorTypeCreateInfoEXT* from,
+                                                   VkMutableDescriptorTypeCreateInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -16223,14 +17909,14 @@ void deepcopy_VkMutableDescriptorTypeCreateInfoVALVE(
     if (from) {
         to->pMutableDescriptorTypeLists = nullptr;
         if (from->pMutableDescriptorTypeLists) {
-            to->pMutableDescriptorTypeLists = (VkMutableDescriptorTypeListVALVE*)alloc->alloc(
+            to->pMutableDescriptorTypeLists = (VkMutableDescriptorTypeListEXT*)alloc->alloc(
                 from->mutableDescriptorTypeListCount *
-                sizeof(const VkMutableDescriptorTypeListVALVE));
+                sizeof(const VkMutableDescriptorTypeListEXT));
             to->mutableDescriptorTypeListCount = from->mutableDescriptorTypeListCount;
             for (uint32_t i = 0; i < (uint32_t)from->mutableDescriptorTypeListCount; ++i) {
-                deepcopy_VkMutableDescriptorTypeListVALVE(
+                deepcopy_VkMutableDescriptorTypeListEXT(
                     alloc, rootType, from->pMutableDescriptorTypeLists + i,
-                    (VkMutableDescriptorTypeListVALVE*)(to->pMutableDescriptorTypeLists + i));
+                    (VkMutableDescriptorTypeListEXT*)(to->pMutableDescriptorTypeLists + i));
             }
         }
     }
@@ -16330,6 +18016,101 @@ void deepcopy_VkPhysicalDeviceDrmPropertiesEXT(Allocator* alloc, VkStructureType
 }
 
 #endif
+#ifdef VK_EXT_device_address_binding_report
+void deepcopy_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* from,
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDeviceAddressBindingCallbackDataEXT(
+    Allocator* alloc, VkStructureType rootType, const VkDeviceAddressBindingCallbackDataEXT* from,
+    VkDeviceAddressBindingCallbackDataEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_depth_clip_control
+void deepcopy_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClipControlFeaturesEXT* from,
+    VkPhysicalDeviceDepthClipControlFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPipelineViewportDepthClipControlCreateInfoEXT* from,
+    VkPipelineViewportDepthClipControlCreateInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 void deepcopy_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
@@ -16681,12 +18462,18 @@ void deepcopy_VkImageFormatConstraintsInfoFUCHSIA(Allocator* alloc, VkStructureT
     }
     deepcopy_VkImageCreateInfo(alloc, rootType, &from->imageCreateInfo,
                                (VkImageCreateInfo*)(&to->imageCreateInfo));
-    to->pColorSpaces = nullptr;
-    if (from->pColorSpaces) {
-        to->pColorSpaces =
-            (VkSysmemColorSpaceFUCHSIA*)alloc->alloc(sizeof(const VkSysmemColorSpaceFUCHSIA));
-        deepcopy_VkSysmemColorSpaceFUCHSIA(alloc, rootType, from->pColorSpaces,
-                                           (VkSysmemColorSpaceFUCHSIA*)(to->pColorSpaces));
+    if (from) {
+        to->pColorSpaces = nullptr;
+        if (from->pColorSpaces) {
+            to->pColorSpaces = (VkSysmemColorSpaceFUCHSIA*)alloc->alloc(
+                from->colorSpaceCount * sizeof(const VkSysmemColorSpaceFUCHSIA));
+            to->colorSpaceCount = from->colorSpaceCount;
+            for (uint32_t i = 0; i < (uint32_t)from->colorSpaceCount; ++i) {
+                deepcopy_VkSysmemColorSpaceFUCHSIA(
+                    alloc, rootType, from->pColorSpaces + i,
+                    (VkSysmemColorSpaceFUCHSIA*)(to->pColorSpaces + i));
+            }
+        }
     }
 }
 
@@ -16872,6 +18659,124 @@ void deepcopy_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
 }
 
 #endif
+#ifdef VK_EXT_pipeline_properties
+void deepcopy_VkPipelinePropertiesIdentifierEXT(Allocator* alloc, VkStructureType rootType,
+                                                const VkPipelinePropertiesIdentifierEXT* from,
+                                                VkPipelinePropertiesIdentifierEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    memcpy(to->pipelineIdentifier, from->pipelineIdentifier, VK_UUID_SIZE * sizeof(uint8_t));
+}
+
+void deepcopy_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePipelinePropertiesFeaturesEXT* from,
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+void deepcopy_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* from,
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkSubpassResolvePerformanceQueryEXT(Allocator* alloc, VkStructureType rootType,
+                                                  const VkSubpassResolvePerformanceQueryEXT* from,
+                                                  VkSubpassResolvePerformanceQueryEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMultisampledRenderToSingleSampledInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkMultisampledRenderToSingleSampledInfoEXT* from,
+    VkMultisampledRenderToSingleSampledInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void deepcopy_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
@@ -16981,6 +18886,31 @@ void deepcopy_VkPipelineColorWriteCreateInfoEXT(Allocator* alloc, VkStructureTyp
 }
 
 #endif
+#ifdef VK_EXT_primitives_generated_query
+void deepcopy_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* from,
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
 #ifdef VK_GOOGLE_gfxstream
 void deepcopy_VkImportColorBufferGOOGLE(Allocator* alloc, VkStructureType rootType,
                                         const VkImportColorBufferGOOGLE* from,
@@ -17048,10 +18978,12 @@ void deepcopy_VkCreateBlobGOOGLE(Allocator* alloc, VkStructureType rootType,
 
 #endif
 #ifdef VK_EXT_global_priority_query
-void deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+#endif
+#ifdef VK_EXT_image_view_min_lod
+void deepcopy_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* from,
-    VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* to) {
+    const VkPhysicalDeviceImageViewMinLodFeaturesEXT* from,
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -17071,10 +19003,9 @@ void deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
     }
 }
 
-void deepcopy_VkQueueFamilyGlobalPriorityPropertiesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkQueueFamilyGlobalPriorityPropertiesEXT* from,
-    VkQueueFamilyGlobalPriorityPropertiesEXT* to) {
+void deepcopy_VkImageViewMinLodCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                             const VkImageViewMinLodCreateInfoEXT* from,
+                                             VkImageViewMinLodCreateInfoEXT* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
@@ -17092,8 +19023,6 @@ void deepcopy_VkQueueFamilyGlobalPriorityPropertiesEXT(
         to->pNext = (void*)alloc->alloc(pNext_size);
         deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
-    memcpy(to->priorities, from->priorities,
-           VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT));
 }
 
 #endif
@@ -17158,8 +19087,516 @@ void deepcopy_VkMultiDrawIndexedInfoEXT(Allocator* alloc, VkStructureType rootTy
 }
 
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+void deepcopy_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* from,
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_tile_image
+void deepcopy_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderTileImageFeaturesEXT* from,
+    VkPhysicalDeviceShaderTileImageFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderTileImagePropertiesEXT* from,
+    VkPhysicalDeviceShaderTileImagePropertiesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_opacity_micromap
+void deepcopy_VkMicromapUsageEXT(Allocator* alloc, VkStructureType rootType,
+                                 const VkMicromapUsageEXT* from, VkMicromapUsageEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+}
+
+void deepcopy_VkDeviceOrHostAddressKHR(Allocator* alloc, VkStructureType rootType,
+                                       const VkDeviceOrHostAddressKHR* from,
+                                       VkDeviceOrHostAddressKHR* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    to->hostAddress = nullptr;
+    if (from->hostAddress) {
+        to->hostAddress = (void*)alloc->dupArray(from->hostAddress, sizeof(uint8_t));
+    }
+}
+
+void deepcopy_VkMicromapBuildInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkMicromapBuildInfoEXT* from,
+                                     VkMicromapBuildInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pUsageCounts = nullptr;
+        if (from->pUsageCounts) {
+            to->pUsageCounts = (VkMicromapUsageEXT*)alloc->alloc(from->usageCountsCount *
+                                                                 sizeof(const VkMicromapUsageEXT));
+            to->usageCountsCount = from->usageCountsCount;
+            for (uint32_t i = 0; i < (uint32_t)from->usageCountsCount; ++i) {
+                deepcopy_VkMicromapUsageEXT(alloc, rootType, from->pUsageCounts + i,
+                                            (VkMicromapUsageEXT*)(to->pUsageCounts + i));
+            }
+        }
+    }
+    deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->data,
+                                           (VkDeviceOrHostAddressConstKHR*)(&to->data));
+    deepcopy_VkDeviceOrHostAddressKHR(alloc, rootType, &from->scratchData,
+                                      (VkDeviceOrHostAddressKHR*)(&to->scratchData));
+    deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->triangleArray,
+                                           (VkDeviceOrHostAddressConstKHR*)(&to->triangleArray));
+}
+
+void deepcopy_VkMicromapCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                      const VkMicromapCreateInfoEXT* from,
+                                      VkMicromapCreateInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceOpacityMicromapFeaturesEXT* from,
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceOpacityMicromapPropertiesEXT* from,
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMicromapVersionInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                       const VkMicromapVersionInfoEXT* from,
+                                       VkMicromapVersionInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pVersionData = nullptr;
+    if (from->pVersionData) {
+        to->pVersionData =
+            (uint8_t*)alloc->dupArray(from->pVersionData, 2 * VK_UUID_SIZE * sizeof(const uint8_t));
+    }
+}
+
+void deepcopy_VkCopyMicromapToMemoryInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkCopyMicromapToMemoryInfoEXT* from,
+                                            VkCopyMicromapToMemoryInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkDeviceOrHostAddressKHR(alloc, rootType, &from->dst,
+                                      (VkDeviceOrHostAddressKHR*)(&to->dst));
+}
+
+void deepcopy_VkCopyMemoryToMicromapInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkCopyMemoryToMicromapInfoEXT* from,
+                                            VkCopyMemoryToMicromapInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->src,
+                                           (VkDeviceOrHostAddressConstKHR*)(&to->src));
+}
+
+void deepcopy_VkCopyMicromapInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                    const VkCopyMicromapInfoEXT* from, VkCopyMicromapInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMicromapBuildSizesInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                          const VkMicromapBuildSizesInfoEXT* from,
+                                          VkMicromapBuildSizesInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkAccelerationStructureTrianglesOpacityMicromapEXT* from,
+    VkAccelerationStructureTrianglesOpacityMicromapEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->indexBuffer,
+                                           (VkDeviceOrHostAddressConstKHR*)(&to->indexBuffer));
+    if (from) {
+        to->pUsageCounts = nullptr;
+        if (from->pUsageCounts) {
+            to->pUsageCounts = (VkMicromapUsageEXT*)alloc->alloc(from->usageCountsCount *
+                                                                 sizeof(const VkMicromapUsageEXT));
+            to->usageCountsCount = from->usageCountsCount;
+            for (uint32_t i = 0; i < (uint32_t)from->usageCountsCount; ++i) {
+                deepcopy_VkMicromapUsageEXT(alloc, rootType, from->pUsageCounts + i,
+                                            (VkMicromapUsageEXT*)(to->pUsageCounts + i));
+            }
+        }
+    }
+}
+
+void deepcopy_VkMicromapTriangleEXT(Allocator* alloc, VkStructureType rootType,
+                                    const VkMicromapTriangleEXT* from, VkMicromapTriangleEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+}
+
+#endif
+#ifdef VK_NV_displacement_micromap
+void deepcopy_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* from,
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* from,
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkAccelerationStructureTrianglesDisplacementMicromapNV* from,
+    VkAccelerationStructureTrianglesDisplacementMicromapNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkDeviceOrHostAddressConstKHR(
+        alloc, rootType, &from->displacementBiasAndScaleBuffer,
+        (VkDeviceOrHostAddressConstKHR*)(&to->displacementBiasAndScaleBuffer));
+    deepcopy_VkDeviceOrHostAddressConstKHR(
+        alloc, rootType, &from->displacementVectorBuffer,
+        (VkDeviceOrHostAddressConstKHR*)(&to->displacementVectorBuffer));
+    deepcopy_VkDeviceOrHostAddressConstKHR(
+        alloc, rootType, &from->displacedMicromapPrimitiveFlags,
+        (VkDeviceOrHostAddressConstKHR*)(&to->displacedMicromapPrimitiveFlags));
+    deepcopy_VkDeviceOrHostAddressConstKHR(alloc, rootType, &from->indexBuffer,
+                                           (VkDeviceOrHostAddressConstKHR*)(&to->indexBuffer));
+    if (from) {
+        to->pUsageCounts = nullptr;
+        if (from->pUsageCounts) {
+            to->pUsageCounts = (VkMicromapUsageEXT*)alloc->alloc(from->usageCountsCount *
+                                                                 sizeof(const VkMicromapUsageEXT));
+            to->usageCountsCount = from->usageCountsCount;
+            for (uint32_t i = 0; i < (uint32_t)from->usageCountsCount; ++i) {
+                deepcopy_VkMicromapUsageEXT(alloc, rootType, from->pUsageCounts + i,
+                                            (VkMicromapUsageEXT*)(to->pUsageCounts + i));
+            }
+        }
+    }
+}
+
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void deepcopy_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* from,
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* from,
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    memcpy(to->maxWorkGroupCount, from->maxWorkGroupCount, 3 * sizeof(uint32_t));
+    memcpy(to->maxWorkGroupSize, from->maxWorkGroupSize, 3 * sizeof(uint32_t));
+}
+
+#endif
 #ifdef VK_EXT_border_color_swizzle
 void deepcopy_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
@@ -17235,19 +19672,1542 @@ void deepcopy_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
 }
 
 #endif
-#ifdef VK_KHR_acceleration_structure
-void deepcopy_VkDeviceOrHostAddressKHR(Allocator* alloc, VkStructureType rootType,
-                                       const VkDeviceOrHostAddressKHR* from,
-                                       VkDeviceOrHostAddressKHR* to) {
+#ifdef VK_ARM_shader_core_properties
+void deepcopy_VkPhysicalDeviceShaderCorePropertiesARM(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceShaderCorePropertiesARM* from,
+    VkPhysicalDeviceShaderCorePropertiesARM* to) {
     (void)alloc;
     (void)rootType;
     *to = *from;
-    to->hostAddress = nullptr;
-    if (from->hostAddress) {
-        to->hostAddress = (void*)alloc->dupArray(from->hostAddress, sizeof(uint8_t));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+void deepcopy_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* from,
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkImageViewSlicedCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                             const VkImageViewSlicedCreateInfoEXT* from,
+                                             VkImageViewSlicedCreateInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void deepcopy_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* from,
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDescriptorSetBindingReferenceVALVE(Allocator* alloc, VkStructureType rootType,
+                                                   const VkDescriptorSetBindingReferenceVALVE* from,
+                                                   VkDescriptorSetBindingReferenceVALVE* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    Allocator* alloc, VkStructureType rootType,
+    const VkDescriptorSetLayoutHostMappingInfoVALVE* from,
+    VkDescriptorSetLayoutHostMappingInfoVALVE* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+void deepcopy_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* from,
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+void deepcopy_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* from,
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+void deepcopy_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* from,
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* from,
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkExtent2D(alloc, rootType, &from->fragmentDensityOffsetGranularity,
+                        (VkExtent2D*)(&to->fragmentDensityOffsetGranularity));
+}
+
+void deepcopy_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* from,
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pFragmentDensityOffsets = nullptr;
+        if (from->pFragmentDensityOffsets) {
+            to->pFragmentDensityOffsets = (VkOffset2D*)alloc->alloc(
+                from->fragmentDensityOffsetCount * sizeof(const VkOffset2D));
+            to->fragmentDensityOffsetCount = from->fragmentDensityOffsetCount;
+            for (uint32_t i = 0; i < (uint32_t)from->fragmentDensityOffsetCount; ++i) {
+                deepcopy_VkOffset2D(alloc, rootType, from->pFragmentDensityOffsets + i,
+                                    (VkOffset2D*)(to->pFragmentDensityOffsets + i));
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void deepcopy_VkCopyMemoryIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+                                            const VkCopyMemoryIndirectCommandNV* from,
+                                            VkCopyMemoryIndirectCommandNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+}
+
+void deepcopy_VkCopyMemoryToImageIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+                                                   const VkCopyMemoryToImageIndirectCommandNV* from,
+                                                   VkCopyMemoryToImageIndirectCommandNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    deepcopy_VkImageSubresourceLayers(alloc, rootType, &from->imageSubresource,
+                                      (VkImageSubresourceLayers*)(&to->imageSubresource));
+    deepcopy_VkOffset3D(alloc, rootType, &from->imageOffset, (VkOffset3D*)(&to->imageOffset));
+    deepcopy_VkExtent3D(alloc, rootType, &from->imageExtent, (VkExtent3D*)(&to->imageExtent));
+}
+
+void deepcopy_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* from,
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* from,
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_memory_decompression
+void deepcopy_VkDecompressMemoryRegionNV(Allocator* alloc, VkStructureType rootType,
+                                         const VkDecompressMemoryRegionNV* from,
+                                         VkDecompressMemoryRegionNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+}
+
+void deepcopy_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceMemoryDecompressionFeaturesNV* from,
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* from,
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_linear_color_attachment
+void deepcopy_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* from,
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+void deepcopy_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* from,
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_image_processing
+void deepcopy_VkImageViewSampleWeightCreateInfoQCOM(
+    Allocator* alloc, VkStructureType rootType, const VkImageViewSampleWeightCreateInfoQCOM* from,
+    VkImageViewSampleWeightCreateInfoQCOM* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkOffset2D(alloc, rootType, &from->filterCenter, (VkOffset2D*)(&to->filterCenter));
+    deepcopy_VkExtent2D(alloc, rootType, &from->filterSize, (VkExtent2D*)(&to->filterSize));
+}
+
+void deepcopy_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceImageProcessingFeaturesQCOM* from,
+    VkPhysicalDeviceImageProcessingFeaturesQCOM* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceImageProcessingPropertiesQCOM* from,
+    VkPhysicalDeviceImageProcessingPropertiesQCOM* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkExtent2D(alloc, rootType, &from->maxWeightFilterDimension,
+                        (VkExtent2D*)(&to->maxWeightFilterDimension));
+    deepcopy_VkExtent2D(alloc, rootType, &from->maxBlockMatchRegion,
+                        (VkExtent2D*)(&to->maxBlockMatchRegion));
+    deepcopy_VkExtent2D(alloc, rootType, &from->maxBoxFilterBlockSize,
+                        (VkExtent2D*)(&to->maxBoxFilterBlockSize));
+}
+
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void deepcopy_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* from,
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* from,
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkColorBlendEquationEXT(Allocator* alloc, VkStructureType rootType,
+                                      const VkColorBlendEquationEXT* from,
+                                      VkColorBlendEquationEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+}
+
+void deepcopy_VkColorBlendAdvancedEXT(Allocator* alloc, VkStructureType rootType,
+                                      const VkColorBlendAdvancedEXT* from,
+                                      VkColorBlendAdvancedEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+}
+
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+void deepcopy_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* from,
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkRenderPassCreationControlEXT(Allocator* alloc, VkStructureType rootType,
+                                             const VkRenderPassCreationControlEXT* from,
+                                             VkRenderPassCreationControlEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkRenderPassCreationFeedbackInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                  const VkRenderPassCreationFeedbackInfoEXT* from,
+                                                  VkRenderPassCreationFeedbackInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+}
+
+void deepcopy_VkRenderPassCreationFeedbackCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkRenderPassCreationFeedbackCreateInfoEXT* from,
+    VkRenderPassCreationFeedbackCreateInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pRenderPassFeedback = nullptr;
+    if (from->pRenderPassFeedback) {
+        to->pRenderPassFeedback = (VkRenderPassCreationFeedbackInfoEXT*)alloc->alloc(
+            sizeof(VkRenderPassCreationFeedbackInfoEXT));
+        deepcopy_VkRenderPassCreationFeedbackInfoEXT(
+            alloc, rootType, from->pRenderPassFeedback,
+            (VkRenderPassCreationFeedbackInfoEXT*)(to->pRenderPassFeedback));
+    }
+}
+
+void deepcopy_VkRenderPassSubpassFeedbackInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                 const VkRenderPassSubpassFeedbackInfoEXT* from,
+                                                 VkRenderPassSubpassFeedbackInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    memcpy(to->description, from->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+}
+
+void deepcopy_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkRenderPassSubpassFeedbackCreateInfoEXT* from,
+    VkRenderPassSubpassFeedbackCreateInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pSubpassFeedback = nullptr;
+    if (from->pSubpassFeedback) {
+        to->pSubpassFeedback = (VkRenderPassSubpassFeedbackInfoEXT*)alloc->alloc(
+            sizeof(VkRenderPassSubpassFeedbackInfoEXT));
+        deepcopy_VkRenderPassSubpassFeedbackInfoEXT(
+            alloc, rootType, from->pSubpassFeedback,
+            (VkRenderPassSubpassFeedbackInfoEXT*)(to->pSubpassFeedback));
+    }
+}
+
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+void deepcopy_VkDirectDriverLoadingInfoLUNARG(Allocator* alloc, VkStructureType rootType,
+                                              const VkDirectDriverLoadingInfoLUNARG* from,
+                                              VkDirectDriverLoadingInfoLUNARG* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkDirectDriverLoadingListLUNARG(Allocator* alloc, VkStructureType rootType,
+                                              const VkDirectDriverLoadingListLUNARG* from,
+                                              VkDirectDriverLoadingListLUNARG* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pDrivers = nullptr;
+        if (from->pDrivers) {
+            to->pDrivers = (VkDirectDriverLoadingInfoLUNARG*)alloc->alloc(
+                from->driverCount * sizeof(const VkDirectDriverLoadingInfoLUNARG));
+            to->driverCount = from->driverCount;
+            for (uint32_t i = 0; i < (uint32_t)from->driverCount; ++i) {
+                deepcopy_VkDirectDriverLoadingInfoLUNARG(
+                    alloc, rootType, from->pDrivers + i,
+                    (VkDirectDriverLoadingInfoLUNARG*)(to->pDrivers + i));
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void deepcopy_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* from,
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* from,
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    memcpy(to->shaderModuleIdentifierAlgorithmUUID, from->shaderModuleIdentifierAlgorithmUUID,
+           VK_UUID_SIZE * sizeof(uint8_t));
+}
+
+void deepcopy_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* from,
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pIdentifier = nullptr;
+    if (from->pIdentifier) {
+        to->pIdentifier = (uint8_t*)alloc->dupArray(from->pIdentifier,
+                                                    from->identifierSize * sizeof(const uint8_t));
+    }
+}
+
+void deepcopy_VkShaderModuleIdentifierEXT(Allocator* alloc, VkStructureType rootType,
+                                          const VkShaderModuleIdentifierEXT* from,
+                                          VkShaderModuleIdentifierEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    memcpy(to->identifier, from->identifier,
+           VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t));
+}
+
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+void deepcopy_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceOpticalFlowFeaturesNV* from,
+    VkPhysicalDeviceOpticalFlowFeaturesNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceOpticalFlowPropertiesNV* from,
+    VkPhysicalDeviceOpticalFlowPropertiesNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkOpticalFlowImageFormatInfoNV(Allocator* alloc, VkStructureType rootType,
+                                             const VkOpticalFlowImageFormatInfoNV* from,
+                                             VkOpticalFlowImageFormatInfoNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkOpticalFlowImageFormatPropertiesNV(Allocator* alloc, VkStructureType rootType,
+                                                   const VkOpticalFlowImageFormatPropertiesNV* from,
+                                                   VkOpticalFlowImageFormatPropertiesNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkOpticalFlowSessionCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+                                               const VkOpticalFlowSessionCreateInfoNV* from,
+                                               VkOpticalFlowSessionCreateInfoNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
     }
 }
 
+void deepcopy_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkOpticalFlowSessionCreatePrivateDataInfoNV* from,
+    VkOpticalFlowSessionCreatePrivateDataInfoNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pPrivateData = nullptr;
+    if (from->pPrivateData) {
+        to->pPrivateData = (void*)alloc->dupArray(from->pPrivateData, sizeof(const uint8_t));
+    }
+}
+
+void deepcopy_VkOpticalFlowExecuteInfoNV(Allocator* alloc, VkStructureType rootType,
+                                         const VkOpticalFlowExecuteInfoNV* from,
+                                         VkOpticalFlowExecuteInfoNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pRegions = nullptr;
+        if (from->pRegions) {
+            to->pRegions = (VkRect2D*)alloc->alloc(from->regionCount * sizeof(const VkRect2D));
+            to->regionCount = from->regionCount;
+            for (uint32_t i = 0; i < (uint32_t)from->regionCount; ++i) {
+                deepcopy_VkRect2D(alloc, rootType, from->pRegions + i,
+                                  (VkRect2D*)(to->pRegions + i));
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_legacy_dithering
+void deepcopy_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceLegacyDitheringFeaturesEXT* from,
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+void deepcopy_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* from,
+    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_object
+void deepcopy_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceShaderObjectFeaturesEXT* from,
+    VkPhysicalDeviceShaderObjectFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderObjectPropertiesEXT* from,
+    VkPhysicalDeviceShaderObjectPropertiesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    memcpy(to->shaderBinaryUUID, from->shaderBinaryUUID, VK_UUID_SIZE * sizeof(uint8_t));
+}
+
+void deepcopy_VkShaderCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                    const VkShaderCreateInfoEXT* from, VkShaderCreateInfoEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    to->pCode = nullptr;
+    if (from->pCode) {
+        to->pCode = (void*)alloc->dupArray(from->pCode, from->codeSize * sizeof(const uint8_t));
+    }
+    to->pName = nullptr;
+    if (from->pName) {
+        to->pName = alloc->strDup(from->pName);
+    }
+    to->pSetLayouts = nullptr;
+    if (from->pSetLayouts) {
+        to->pSetLayouts = (VkDescriptorSetLayout*)alloc->dupArray(
+            from->pSetLayouts, from->setLayoutCount * sizeof(const VkDescriptorSetLayout));
+    }
+    if (from) {
+        to->pPushConstantRanges = nullptr;
+        if (from->pPushConstantRanges) {
+            to->pPushConstantRanges = (VkPushConstantRange*)alloc->alloc(
+                from->pushConstantRangeCount * sizeof(const VkPushConstantRange));
+            to->pushConstantRangeCount = from->pushConstantRangeCount;
+            for (uint32_t i = 0; i < (uint32_t)from->pushConstantRangeCount; ++i) {
+                deepcopy_VkPushConstantRange(alloc, rootType, from->pPushConstantRanges + i,
+                                             (VkPushConstantRange*)(to->pPushConstantRanges + i));
+            }
+        }
+    }
+    to->pSpecializationInfo = nullptr;
+    if (from->pSpecializationInfo) {
+        to->pSpecializationInfo =
+            (VkSpecializationInfo*)alloc->alloc(sizeof(const VkSpecializationInfo));
+        deepcopy_VkSpecializationInfo(alloc, rootType, from->pSpecializationInfo,
+                                      (VkSpecializationInfo*)(to->pSpecializationInfo));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_tile_properties
+void deepcopy_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceTilePropertiesFeaturesQCOM* from,
+    VkPhysicalDeviceTilePropertiesFeaturesQCOM* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkTilePropertiesQCOM(Allocator* alloc, VkStructureType rootType,
+                                   const VkTilePropertiesQCOM* from, VkTilePropertiesQCOM* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    deepcopy_VkExtent3D(alloc, rootType, &from->tileSize, (VkExtent3D*)(&to->tileSize));
+    deepcopy_VkExtent2D(alloc, rootType, &from->apronSize, (VkExtent2D*)(&to->apronSize));
+    deepcopy_VkOffset2D(alloc, rootType, &from->origin, (VkOffset2D*)(&to->origin));
+}
+
+#endif
+#ifdef VK_SEC_amigo_profiling
+void deepcopy_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceAmigoProfilingFeaturesSEC* from,
+    VkPhysicalDeviceAmigoProfilingFeaturesSEC* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkAmigoProfilingSubmitInfoSEC(Allocator* alloc, VkStructureType rootType,
+                                            const VkAmigoProfilingSubmitInfoSEC* from,
+                                            VkAmigoProfilingSubmitInfoSEC* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+void deepcopy_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* from,
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+void deepcopy_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* from,
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* from,
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+void deepcopy_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* from,
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* from,
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+void deepcopy_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* from,
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+void deepcopy_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* from,
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* from,
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    if (from) {
+        to->pPerViewRenderAreas = nullptr;
+        if (from->pPerViewRenderAreas) {
+            to->pPerViewRenderAreas =
+                (VkRect2D*)alloc->alloc(from->perViewRenderAreaCount * sizeof(const VkRect2D));
+            to->perViewRenderAreaCount = from->perViewRenderAreaCount;
+            for (uint32_t i = 0; i < (uint32_t)from->perViewRenderAreaCount; ++i) {
+                deepcopy_VkRect2D(alloc, rootType, from->pPerViewRenderAreas + i,
+                                  (VkRect2D*)(to->pPerViewRenderAreas + i));
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+void deepcopy_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* from,
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_acceleration_structure
 void deepcopy_VkAccelerationStructureBuildRangeInfoKHR(
     Allocator* alloc, VkStructureType rootType,
     const VkAccelerationStructureBuildRangeInfoKHR* from,
@@ -17867,6 +21827,64 @@ void deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(Allocator* alloc, VkStructureT
 }
 
 #endif
+#ifdef VK_EXT_mesh_shader
+void deepcopy_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMeshShaderFeaturesEXT* from,
+    VkPhysicalDeviceMeshShaderFeaturesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+}
+
+void deepcopy_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMeshShaderPropertiesEXT* from,
+    VkPhysicalDeviceMeshShaderPropertiesEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = from->sType;
+    }
+    const void* from_pNext = from;
+    size_t pNext_size = 0u;
+    while (!pNext_size && from_pNext) {
+        from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+        pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+    }
+    to->pNext = nullptr;
+    if (pNext_size) {
+        to->pNext = (void*)alloc->alloc(pNext_size);
+        deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+    }
+    memcpy(to->maxTaskWorkGroupCount, from->maxTaskWorkGroupCount, 3 * sizeof(uint32_t));
+    memcpy(to->maxTaskWorkGroupSize, from->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
+    memcpy(to->maxMeshWorkGroupCount, from->maxMeshWorkGroupCount, 3 * sizeof(uint32_t));
+    memcpy(to->maxMeshWorkGroupSize, from->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
+}
+
+void deepcopy_VkDrawMeshTasksIndirectCommandEXT(Allocator* alloc, VkStructureType rootType,
+                                                const VkDrawMeshTasksIndirectCommandEXT* from,
+                                                VkDrawMeshTasksIndirectCommandEXT* to) {
+    (void)alloc;
+    (void)rootType;
+    *to = *from;
+}
+
+#endif
 void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                                const void* structExtension, void* structExtension_out) {
     if (!structExtension) {
@@ -17874,6 +21892,14 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
     }
     uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
     switch (structType) {
+#ifdef VK_VERSION_1_0
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
+            deepcopy_VkShaderModuleCreateInfo(
+                alloc, rootType, reinterpret_cast<const VkShaderModuleCreateInfo*>(structExtension),
+                reinterpret_cast<VkShaderModuleCreateInfo*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_VERSION_1_1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
             deepcopy_VkPhysicalDeviceSubgroupProperties(
@@ -18449,6 +22475,236 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
+            deepcopy_VkPhysicalDeviceVulkan13Features(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceVulkan13Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: {
+            deepcopy_VkPhysicalDeviceVulkan13Properties(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceVulkan13Properties*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceVulkan13Properties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: {
+            deepcopy_VkPipelineCreationFeedbackCreateInfo(
+                alloc, rootType,
+                reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo*>(structExtension),
+                reinterpret_cast<VkPipelineCreationFeedbackCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
+            deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
+            deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
+            deepcopy_VkPhysicalDevicePrivateDataFeatures(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(structExtension),
+                reinterpret_cast<VkPhysicalDevicePrivateDataFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: {
+            deepcopy_VkDevicePrivateDataCreateInfo(
+                alloc, rootType,
+                reinterpret_cast<const VkDevicePrivateDataCreateInfo*>(structExtension),
+                reinterpret_cast<VkDevicePrivateDataCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
+            deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: {
+            deepcopy_VkMemoryBarrier2(alloc, rootType,
+                                      reinterpret_cast<const VkMemoryBarrier2*>(structExtension),
+                                      reinterpret_cast<VkMemoryBarrier2*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
+            deepcopy_VkPhysicalDeviceSynchronization2Features(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceSynchronization2Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
+            deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
+            deepcopy_VkPhysicalDeviceImageRobustnessFeatures(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceImageRobustnessFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
+            deepcopy_VkPhysicalDeviceSubgroupSizeControlFeatures(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
+            deepcopy_VkPhysicalDeviceSubgroupSizeControlProperties(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlProperties*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: {
+            deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+                alloc, rootType,
+                reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(
+                    structExtension),
+                reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
+            deepcopy_VkPhysicalDeviceInlineUniformBlockFeatures(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
+            deepcopy_VkPhysicalDeviceInlineUniformBlockProperties(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockProperties*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: {
+            deepcopy_VkWriteDescriptorSetInlineUniformBlock(
+                alloc, rootType,
+                reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock*>(structExtension),
+                reinterpret_cast<VkWriteDescriptorSetInlineUniformBlock*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: {
+            deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfo(
+                alloc, rootType,
+                reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo*>(
+                    structExtension),
+                reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
+            deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: {
+            deepcopy_VkPipelineRenderingCreateInfo(
+                alloc, rootType,
+                reinterpret_cast<const VkPipelineRenderingCreateInfo*>(structExtension),
+                reinterpret_cast<VkPipelineRenderingCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
+            deepcopy_VkPhysicalDeviceDynamicRenderingFeatures(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: {
+            deepcopy_VkCommandBufferInheritanceRenderingInfo(
+                alloc, rootType,
+                reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo*>(structExtension),
+                reinterpret_cast<VkCommandBufferInheritanceRenderingInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
+            deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
+            deepcopy_VkPhysicalDeviceShaderIntegerDotProductProperties(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductProperties*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
+            deepcopy_VkPhysicalDeviceTexelBufferAlignmentProperties(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentProperties*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
+            deepcopy_VkFormatProperties3(
+                alloc, rootType, reinterpret_cast<const VkFormatProperties3*>(structExtension),
+                reinterpret_cast<VkFormatProperties3*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
+            deepcopy_VkPhysicalDeviceMaintenance4Features(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceMaintenance4Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
+            deepcopy_VkPhysicalDeviceMaintenance4Properties(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceMaintenance4Properties*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_KHR_swapchain
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
             deepcopy_VkImageSwapchainCreateInfoKHR(
@@ -18488,51 +22744,101 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
         }
 #endif
 #ifdef VK_KHR_video_queue
-        case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
-            deepcopy_VkVideoQueueFamilyProperties2KHR(
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: {
+            deepcopy_VkQueueFamilyQueryResultStatusPropertiesKHR(
                 alloc, rootType,
-                reinterpret_cast<const VkVideoQueueFamilyProperties2KHR*>(structExtension),
-                reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
+                reinterpret_cast<const VkQueueFamilyQueryResultStatusPropertiesKHR*>(
+                    structExtension),
+                reinterpret_cast<VkQueueFamilyQueryResultStatusPropertiesKHR*>(
+                    structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
-            deepcopy_VkVideoProfileKHR(alloc, rootType,
-                                       reinterpret_cast<const VkVideoProfileKHR*>(structExtension),
-                                       reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: {
+            deepcopy_VkQueueFamilyVideoPropertiesKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkQueueFamilyVideoPropertiesKHR*>(structExtension),
+                reinterpret_cast<VkQueueFamilyVideoPropertiesKHR*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
-            deepcopy_VkVideoProfilesKHR(
-                alloc, rootType, reinterpret_cast<const VkVideoProfilesKHR*>(structExtension),
-                reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: {
+            deepcopy_VkVideoProfileInfoKHR(
+                alloc, rootType, reinterpret_cast<const VkVideoProfileInfoKHR*>(structExtension),
+                reinterpret_cast<VkVideoProfileInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: {
+            deepcopy_VkVideoProfileListInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoProfileListInfoKHR*>(structExtension),
+                reinterpret_cast<VkVideoProfileListInfoKHR*>(structExtension_out));
             break;
         }
 #endif
-#ifdef VK_KHR_dynamic_rendering
-        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
-            deepcopy_VkPipelineRenderingCreateInfoKHR(
+#ifdef VK_KHR_video_decode_queue
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: {
+            deepcopy_VkVideoDecodeCapabilitiesKHR(
                 alloc, rootType,
-                reinterpret_cast<const VkPipelineRenderingCreateInfoKHR*>(structExtension),
-                reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
+                reinterpret_cast<const VkVideoDecodeCapabilitiesKHR*>(structExtension),
+                reinterpret_cast<VkVideoDecodeCapabilitiesKHR*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
-            deepcopy_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: {
+            deepcopy_VkVideoDecodeUsageInfoKHR(
                 alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+                reinterpret_cast<const VkVideoDecodeUsageInfoKHR*>(structExtension),
+                reinterpret_cast<VkVideoDecodeUsageInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_video_decode_h264
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: {
+            deepcopy_VkVideoDecodeH264ProfileInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoDecodeH264ProfileInfoKHR*>(structExtension),
+                reinterpret_cast<VkVideoDecodeH264ProfileInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: {
+            deepcopy_VkVideoDecodeH264CapabilitiesKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoDecodeH264CapabilitiesKHR*>(structExtension),
+                reinterpret_cast<VkVideoDecodeH264CapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            deepcopy_VkVideoDecodeH264SessionParametersAddInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoKHR*>(
                     structExtension),
-                reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+                reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoKHR*>(
                     structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
-            deepcopy_VkCommandBufferInheritanceRenderingInfoKHR(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            deepcopy_VkVideoDecodeH264SessionParametersCreateInfoKHR(
                 alloc, rootType,
-                reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR*>(
+                reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoKHR*>(
                     structExtension),
-                reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
+                reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoKHR*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: {
+            deepcopy_VkVideoDecodeH264PictureInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoDecodeH264PictureInfoKHR*>(structExtension),
+                reinterpret_cast<VkVideoDecodeH264PictureInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: {
+            deepcopy_VkVideoDecodeH264DpbSlotInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR*>(structExtension),
+                reinterpret_cast<VkVideoDecodeH264DpbSlotInfoKHR*>(structExtension_out));
             break;
         }
+#endif
+#ifdef VK_KHR_dynamic_rendering
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
             deepcopy_VkRenderingFragmentShadingRateAttachmentInfoKHR(
                 alloc, rootType,
@@ -18687,6 +22993,7 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
         }
 #endif
 #ifdef VK_KHR_portability_subset
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
             deepcopy_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
                 alloc, rootType,
@@ -18696,6 +23003,8 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                     structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
             deepcopy_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
                 alloc, rootType,
@@ -18705,6 +23014,7 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                     structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_shader_clock
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
@@ -18715,16 +23025,78 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_KHR_shader_terminate_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
-            deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+#ifdef VK_KHR_video_decode_h265
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: {
+            deepcopy_VkVideoDecodeH265ProfileInfoKHR(
                 alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+                reinterpret_cast<const VkVideoDecodeH265ProfileInfoKHR*>(structExtension),
+                reinterpret_cast<VkVideoDecodeH265ProfileInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: {
+            deepcopy_VkVideoDecodeH265CapabilitiesKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoDecodeH265CapabilitiesKHR*>(structExtension),
+                reinterpret_cast<VkVideoDecodeH265CapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            deepcopy_VkVideoDecodeH265SessionParametersAddInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoKHR*>(
                     structExtension),
-                reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+                reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoKHR*>(
                     structExtension_out));
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            deepcopy_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoKHR*>(
+                    structExtension),
+                reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoKHR*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: {
+            deepcopy_VkVideoDecodeH265PictureInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoDecodeH265PictureInfoKHR*>(structExtension),
+                reinterpret_cast<VkVideoDecodeH265PictureInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: {
+            deepcopy_VkVideoDecodeH265DpbSlotInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR*>(structExtension),
+                reinterpret_cast<VkVideoDecodeH265DpbSlotInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: {
+            deepcopy_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoKHR*>(structExtension),
+                reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: {
+            deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: {
+            deepcopy_VkQueueFamilyGlobalPriorityPropertiesKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesKHR*>(structExtension),
+                reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesKHR*>(structExtension_out));
+            break;
+        }
 #endif
 #ifdef VK_KHR_fragment_shading_rate
         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
@@ -18791,23 +23163,12 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
-            deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-                alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
-                    structExtension),
-                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
-            deepcopy_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+#ifdef VK_KHR_pipeline_library
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+            deepcopy_VkPipelineLibraryCreateInfoKHR(
                 alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
-                    structExtension),
-                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
-                    structExtension_out));
+                reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>(structExtension),
+                reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(structExtension_out));
             break;
         }
 #endif
@@ -18827,6 +23188,45 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
         }
 #endif
 #ifdef VK_KHR_video_encode_queue
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: {
+            deepcopy_VkVideoEncodeCapabilitiesKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>(structExtension),
+                reinterpret_cast<VkVideoEncodeCapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: {
+            deepcopy_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(
+                    structExtension),
+                reinterpret_cast<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(
+                    structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: {
+            deepcopy_VkVideoEncodeUsageInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoEncodeUsageInfoKHR*>(structExtension),
+                reinterpret_cast<VkVideoEncodeUsageInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: {
+            deepcopy_VkVideoEncodeRateControlLayerInfoKHR(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoEncodeRateControlLayerInfoKHR*>(structExtension),
+                reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
             deepcopy_VkVideoEncodeRateControlInfoKHR(
                 alloc, rootType,
@@ -18834,28 +23234,34 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                 reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_synchronization2
-        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
-            deepcopy_VkMemoryBarrier2KHR(
-                alloc, rootType, reinterpret_cast<const VkMemoryBarrier2KHR*>(structExtension),
-                reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
+            deepcopy_VkQueueFamilyCheckpointProperties2NV(
+                alloc, rootType,
+                reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension),
+                reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
-            deepcopy_VkPhysicalDeviceSynchronization2FeaturesKHR(
+#endif
+#ifdef VK_KHR_fragment_shader_barycentric
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
+            deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
                 alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(
                     structExtension),
-                reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(
                     structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
-            deepcopy_VkQueueFamilyCheckpointProperties2NV(
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: {
+            deepcopy_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
                 alloc, rootType,
-                reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension),
-                reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
+                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(
+                    structExtension_out));
             break;
         }
 #endif
@@ -18871,17 +23277,6 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_KHR_zero_initialize_workgroup_memory
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
-            deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-                alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
-                    structExtension),
-                reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
             deepcopy_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
@@ -18893,27 +23288,25 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_KHR_format_feature_flags2
-        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
-            deepcopy_VkFormatProperties3KHR(
-                alloc, rootType, reinterpret_cast<const VkFormatProperties3KHR*>(structExtension),
-                reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
-            break;
-        }
-#endif
-#ifdef VK_KHR_maintenance4
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
-            deepcopy_VkPhysicalDeviceMaintenance4FeaturesKHR(
+#ifdef VK_KHR_ray_tracing_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
+            deepcopy_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
                 alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension),
-                reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
+                reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
+                    structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
-            deepcopy_VkPhysicalDeviceMaintenance4PropertiesKHR(
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
+            deepcopy_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
                 alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension),
-                reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
+                reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(
+                    structExtension_out));
             break;
         }
 #endif
@@ -18998,6 +23391,7 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
         }
 #endif
 #ifdef VK_EXT_video_encode_h264
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
             deepcopy_VkVideoEncodeH264CapabilitiesEXT(
                 alloc, rootType,
@@ -19005,13 +23399,8 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                 reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
-            deepcopy_VkVideoEncodeH264SessionCreateInfoEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension),
-                reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
             deepcopy_VkVideoEncodeH264SessionParametersAddInfoEXT(
                 alloc, rootType,
@@ -19021,6 +23410,8 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                     structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             deepcopy_VkVideoEncodeH264SessionParametersCreateInfoEXT(
                 alloc, rootType,
@@ -19030,6 +23421,8 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                     structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
             deepcopy_VkVideoEncodeH264VclFrameInfoEXT(
                 alloc, rootType,
@@ -19037,22 +23430,46 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                 reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
-            deepcopy_VkVideoEncodeH264EmitPictureParametersEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: {
+            deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoEXT*>(structExtension),
+                reinterpret_cast<VkVideoEncodeH264DpbSlotInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: {
+            deepcopy_VkVideoEncodeH264ProfileInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkVideoEncodeH264ProfileInfoEXT*>(structExtension),
+                reinterpret_cast<VkVideoEncodeH264ProfileInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: {
+            deepcopy_VkVideoEncodeH264RateControlInfoEXT(
                 alloc, rootType,
-                reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension),
-                reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
+                reinterpret_cast<const VkVideoEncodeH264RateControlInfoEXT*>(structExtension),
+                reinterpret_cast<VkVideoEncodeH264RateControlInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
-            deepcopy_VkVideoEncodeH264ProfileEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: {
+            deepcopy_VkVideoEncodeH264RateControlLayerInfoEXT(
                 alloc, rootType,
-                reinterpret_cast<const VkVideoEncodeH264ProfileEXT*>(structExtension),
-                reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
+                reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoEXT*>(structExtension),
+                reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoEXT*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_EXT_video_encode_h265
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
             deepcopy_VkVideoEncodeH265CapabilitiesEXT(
                 alloc, rootType,
@@ -19060,13 +23477,8 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                 reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
-            deepcopy_VkVideoEncodeH265SessionCreateInfoEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension),
-                reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
             deepcopy_VkVideoEncodeH265SessionParametersAddInfoEXT(
                 alloc, rootType,
@@ -19076,6 +23488,8 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                     structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             deepcopy_VkVideoEncodeH265SessionParametersCreateInfoEXT(
                 alloc, rootType,
@@ -19085,6 +23499,8 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                     structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
             deepcopy_VkVideoEncodeH265VclFrameInfoEXT(
                 alloc, rootType,
@@ -19092,81 +23508,43 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                 reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
-            deepcopy_VkVideoEncodeH265EmitPictureParametersEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension),
-                reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
-            deepcopy_VkVideoEncodeH265ProfileEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoEncodeH265ProfileEXT*>(structExtension),
-                reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
-            break;
-        }
-#endif
-#ifdef VK_EXT_video_decode_h264
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
-            deepcopy_VkVideoDecodeH264ProfileEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH264ProfileEXT*>(structExtension),
-                reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
-            deepcopy_VkVideoDecodeH264CapabilitiesEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: {
+            deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(
                 alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT*>(structExtension),
-                reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
+                reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoEXT*>(structExtension),
+                reinterpret_cast<VkVideoEncodeH265DpbSlotInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
-            deepcopy_VkVideoDecodeH264SessionCreateInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: {
+            deepcopy_VkVideoEncodeH265ProfileInfoEXT(
                 alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension),
-                reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
+                reinterpret_cast<const VkVideoEncodeH265ProfileInfoEXT*>(structExtension),
+                reinterpret_cast<VkVideoEncodeH265ProfileInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            deepcopy_VkVideoDecodeH264SessionParametersAddInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: {
+            deepcopy_VkVideoEncodeH265RateControlInfoEXT(
                 alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT*>(
-                    structExtension),
-                reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            deepcopy_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
-                    structExtension),
-                reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
-            deepcopy_VkVideoDecodeH264PictureInfoEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT*>(structExtension),
-                reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
-            deepcopy_VkVideoDecodeH264MvcEXT(
-                alloc, rootType, reinterpret_cast<const VkVideoDecodeH264MvcEXT*>(structExtension),
-                reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
+                reinterpret_cast<const VkVideoEncodeH265RateControlInfoEXT*>(structExtension),
+                reinterpret_cast<VkVideoEncodeH265RateControlInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
-            deepcopy_VkVideoDecodeH264DpbSlotInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: {
+            deepcopy_VkVideoEncodeH265RateControlLayerInfoEXT(
                 alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension),
-                reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
+                reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoEXT*>(structExtension),
+                reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoEXT*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
@@ -19237,17 +23615,6 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_texture_compression_astc_hdr
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
-            deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
-                    structExtension),
-                reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_astc_decode_mode
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
             deepcopy_VkImageViewASTCDecodeModeEXT(
@@ -19264,6 +23631,33 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_robustness
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: {
+            deepcopy_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: {
+            deepcopy_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: {
+            deepcopy_VkPipelineRobustnessCreateInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPipelineRobustnessCreateInfoEXT*>(structExtension),
+                reinterpret_cast<VkPipelineRobustnessCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_conditional_rendering
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
             deepcopy_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
@@ -19393,6 +23787,13 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
         }
 #endif
 #ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+            deepcopy_VkDebugUtilsObjectNameInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(structExtension),
+                reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(structExtension_out));
+            break;
+        }
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
             deepcopy_VkDebugUtilsMessengerCreateInfoEXT(
                 alloc, rootType,
@@ -19441,42 +23842,6 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_inline_uniform_block
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
-            deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
-                    structExtension),
-                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
-            deepcopy_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
-                    structExtension),
-                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
-            deepcopy_VkWriteDescriptorSetInlineUniformBlockEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension),
-                reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
-            deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
-                    structExtension),
-                reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_sample_locations
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
             deepcopy_VkSampleLocationsInfoEXT(
@@ -19725,15 +24090,6 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
-            deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension),
-                reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_external_memory_host
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
             deepcopy_VkImportMemoryHostPointerInfoEXT(
@@ -19770,61 +24126,6 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_video_decode_h265
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
-            deepcopy_VkVideoDecodeH265ProfileEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH265ProfileEXT*>(structExtension),
-                reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
-            deepcopy_VkVideoDecodeH265CapabilitiesEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT*>(structExtension),
-                reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
-            deepcopy_VkVideoDecodeH265SessionCreateInfoEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension),
-                reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            deepcopy_VkVideoDecodeH265SessionParametersAddInfoEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT*>(
-                    structExtension),
-                reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            deepcopy_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
-                    structExtension),
-                reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
-            deepcopy_VkVideoDecodeH265PictureInfoEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT*>(structExtension),
-                reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
-            deepcopy_VkVideoDecodeH265DpbSlotInfoEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension),
-                reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
             deepcopy_VkDeviceMemoryOverallocationCreateInfoAMD(
@@ -19871,15 +24172,6 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_pipeline_creation_feedback
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
-            deepcopy_VkPipelineCreationFeedbackCreateInfoEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension),
-                reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_NV_compute_shader_derivatives
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
             deepcopy_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
@@ -19907,17 +24199,6 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_NV_fragment_shader_barycentric
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
-            deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-                alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
-                    structExtension),
-                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_NV_shader_image_footprint
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
             deepcopy_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -20113,35 +24394,6 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_subgroup_size_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
-            deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
-                    structExtension),
-                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
-            deepcopy_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
-                    structExtension),
-                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
-            deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
-                    structExtension),
-                reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_AMD_shader_core_properties2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
             deepcopy_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -20419,16 +24671,66 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
-            deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: {
+            deepcopy_VkSurfacePresentModeEXT(
+                alloc, rootType, reinterpret_cast<const VkSurfacePresentModeEXT*>(structExtension),
+                reinterpret_cast<VkSurfacePresentModeEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
+            deepcopy_VkSurfacePresentScalingCapabilitiesEXT(
                 alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+                reinterpret_cast<const VkSurfacePresentScalingCapabilitiesEXT*>(structExtension),
+                reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
+            deepcopy_VkSurfacePresentModeCompatibilityEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkSurfacePresentModeCompatibilityEXT*>(structExtension),
+                reinterpret_cast<VkSurfacePresentModeCompatibilityEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(
                     structExtension),
-                reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+                reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(
                     structExtension_out));
             break;
         }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: {
+            deepcopy_VkSwapchainPresentFenceInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkSwapchainPresentFenceInfoEXT*>(structExtension),
+                reinterpret_cast<VkSwapchainPresentFenceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: {
+            deepcopy_VkSwapchainPresentModesCreateInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkSwapchainPresentModesCreateInfoEXT*>(structExtension),
+                reinterpret_cast<VkSwapchainPresentModesCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: {
+            deepcopy_VkSwapchainPresentModeInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkSwapchainPresentModeInfoEXT*>(structExtension),
+                reinterpret_cast<VkSwapchainPresentModeInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: {
+            deepcopy_VkSwapchainPresentScalingCreateInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkSwapchainPresentScalingCreateInfoEXT*>(structExtension),
+                reinterpret_cast<VkSwapchainPresentScalingCreateInfoEXT*>(structExtension_out));
+            break;
+        }
 #endif
 #ifdef VK_NV_device_generated_commands
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
@@ -20488,15 +24790,6 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
                     structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
-            deepcopy_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-                alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
-                    structExtension),
-                reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
-                    structExtension_out));
-            break;
-        }
 #endif
 #ifdef VK_QCOM_render_pass_transform
         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
@@ -20577,30 +24870,26 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_private_data
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
-            deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT(
+#ifdef VK_NV_present_barrier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
+            deepcopy_VkPhysicalDevicePresentBarrierFeaturesNV(
                 alloc, rootType,
-                reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension),
-                reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
+                reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(structExtension),
+                reinterpret_cast<VkPhysicalDevicePresentBarrierFeaturesNV*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
-            deepcopy_VkDevicePrivateDataCreateInfoEXT(
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: {
+            deepcopy_VkSurfaceCapabilitiesPresentBarrierNV(
                 alloc, rootType,
-                reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension),
-                reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
+                reinterpret_cast<const VkSurfaceCapabilitiesPresentBarrierNV*>(structExtension),
+                reinterpret_cast<VkSurfaceCapabilitiesPresentBarrierNV*>(structExtension_out));
             break;
         }
-#endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
-            deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: {
+            deepcopy_VkSwapchainPresentBarrierCreateInfoNV(
                 alloc, rootType,
-                reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
-                    structExtension),
-                reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
-                    structExtension_out));
+                reinterpret_cast<const VkSwapchainPresentBarrierCreateInfoNV*>(structExtension),
+                reinterpret_cast<VkSwapchainPresentBarrierCreateInfoNV*>(structExtension_out));
             break;
         }
 #endif
@@ -20622,6 +24911,178 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_NV_low_latency
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: {
+            deepcopy_VkQueryLowLatencySupportNV(
+                alloc, rootType,
+                reinterpret_cast<const VkQueryLowLatencySupportNV*>(structExtension),
+                reinterpret_cast<VkQueryLowLatencySupportNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_metal_objects
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: {
+            deepcopy_VkExportMetalObjectCreateInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkExportMetalObjectCreateInfoEXT*>(structExtension),
+                reinterpret_cast<VkExportMetalObjectCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: {
+            deepcopy_VkExportMetalDeviceInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkExportMetalDeviceInfoEXT*>(structExtension),
+                reinterpret_cast<VkExportMetalDeviceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: {
+            deepcopy_VkExportMetalCommandQueueInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkExportMetalCommandQueueInfoEXT*>(structExtension),
+                reinterpret_cast<VkExportMetalCommandQueueInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: {
+            deepcopy_VkExportMetalBufferInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkExportMetalBufferInfoEXT*>(structExtension),
+                reinterpret_cast<VkExportMetalBufferInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: {
+            deepcopy_VkImportMetalBufferInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkImportMetalBufferInfoEXT*>(structExtension),
+                reinterpret_cast<VkImportMetalBufferInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: {
+            deepcopy_VkExportMetalTextureInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkExportMetalTextureInfoEXT*>(structExtension),
+                reinterpret_cast<VkExportMetalTextureInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: {
+            deepcopy_VkImportMetalTextureInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkImportMetalTextureInfoEXT*>(structExtension),
+                reinterpret_cast<VkImportMetalTextureInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: {
+            deepcopy_VkExportMetalIOSurfaceInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkExportMetalIOSurfaceInfoEXT*>(structExtension),
+                reinterpret_cast<VkExportMetalIOSurfaceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: {
+            deepcopy_VkImportMetalIOSurfaceInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkImportMetalIOSurfaceInfoEXT*>(structExtension),
+                reinterpret_cast<VkImportMetalIOSurfaceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            deepcopy_VkExportMetalSharedEventInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkExportMetalSharedEventInfoEXT*>(structExtension),
+                reinterpret_cast<VkExportMetalSharedEventInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            deepcopy_VkImportMetalSharedEventInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkImportMetalSharedEventInfoEXT*>(structExtension),
+                reinterpret_cast<VkImportMetalSharedEventInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: {
+            deepcopy_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: {
+            deepcopy_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: {
+            deepcopy_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(
+                    structExtension),
+                reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: {
+            deepcopy_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(
+                    structExtension),
+                reinterpret_cast<VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: {
+            deepcopy_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: {
+            deepcopy_VkGraphicsPipelineLibraryCreateInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkGraphicsPipelineLibraryCreateInfoEXT*>(structExtension),
+                reinterpret_cast<VkGraphicsPipelineLibraryCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
+            deepcopy_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
             deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -20718,13 +25179,39 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_image_robustness
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
-            deepcopy_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+#ifdef VK_EXT_image_compression_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
                 alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(
+                reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
                     structExtension),
-                reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
+            deepcopy_VkImageCompressionControlEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkImageCompressionControlEXT*>(structExtension),
+                reinterpret_cast<VkImageCompressionControlEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
+            deepcopy_VkImageCompressionPropertiesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkImageCompressionPropertiesEXT*>(structExtension),
+                reinterpret_cast<VkImageCompressionPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(
+                    structExtension_out));
             break;
         }
 #endif
@@ -20737,6 +25224,27 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_device_fault
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceFaultFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceFaultFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<
+                    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_rgba10x6_formats
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
             deepcopy_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
@@ -20748,20 +25256,20 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
         }
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
-            deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
                 alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+                reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(
                     structExtension),
-                reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+                reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(
                     structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
-            deepcopy_VkMutableDescriptorTypeCreateInfoVALVE(
+        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: {
+            deepcopy_VkMutableDescriptorTypeCreateInfoEXT(
                 alloc, rootType,
-                reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension),
-                reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
+                reinterpret_cast<const VkMutableDescriptorTypeCreateInfoEXT*>(structExtension),
+                reinterpret_cast<VkMutableDescriptorTypeCreateInfoEXT*>(structExtension_out));
             break;
         }
 #endif
@@ -20785,6 +25293,44 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_device_address_binding_report
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: {
+            deepcopy_VkDeviceAddressBindingCallbackDataEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkDeviceAddressBindingCallbackDataEXT*>(structExtension),
+                reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clip_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: {
+            deepcopy_VkPipelineViewportDepthClipControlCreateInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
             deepcopy_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
@@ -20877,6 +25423,44 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
+            deepcopy_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<
+                    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: {
+            deepcopy_VkSubpassResolvePerformanceQueryEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkSubpassResolvePerformanceQueryEXT*>(structExtension),
+                reinterpret_cast<VkSubpassResolvePerformanceQueryEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: {
+            deepcopy_VkMultisampledRenderToSingleSampledInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkMultisampledRenderToSingleSampledInfoEXT*>(
+                    structExtension),
+                reinterpret_cast<VkMultisampledRenderToSingleSampledInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
             deepcopy_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
@@ -20906,6 +25490,17 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_primitives_generated_query
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
+            deepcopy_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_GOOGLE_gfxstream
         case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
             deepcopy_VkImportColorBufferGOOGLE(
@@ -20927,21 +25522,20 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority_query
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
-            deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+#ifdef VK_EXT_image_view_min_lod
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
                 alloc, rootType,
-                reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
+                reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(
                     structExtension),
-                reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
-                    structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
-            deepcopy_VkQueueFamilyGlobalPriorityPropertiesEXT(
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: {
+            deepcopy_VkImageViewMinLodCreateInfoEXT(
                 alloc, rootType,
-                reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension),
-                reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
+                reinterpret_cast<const VkImageViewMinLodCreateInfoEXT*>(structExtension),
+                reinterpret_cast<VkImageViewMinLodCreateInfoEXT*>(structExtension_out));
             break;
         }
 #endif
@@ -20961,6 +25555,118 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_tile_image
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: {
+            deepcopy_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderTileImagePropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderTileImagePropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: {
+            deepcopy_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: {
+            deepcopy_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapEXT*>(
+                    structExtension),
+                reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_displacement_micromap
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
+            deepcopy_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: {
+            deepcopy_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: {
+            deepcopy_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+                alloc, rootType,
+                reinterpret_cast<const VkAccelerationStructureTrianglesDisplacementMicromapNV*>(
+                    structExtension),
+                reinterpret_cast<VkAccelerationStructureTrianglesDisplacementMicromapNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
+            deepcopy_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: {
+            deepcopy_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_border_color_swizzle
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
             deepcopy_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
@@ -20992,6 +25698,464 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_ARM_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: {
+            deepcopy_VkPhysicalDeviceShaderCorePropertiesARM(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesARM*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: {
+            deepcopy_VkImageViewSlicedCreateInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkImageViewSlicedCreateInfoEXT*>(structExtension),
+                reinterpret_cast<VkImageViewSlicedCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
+            deepcopy_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: {
+            deepcopy_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: {
+            deepcopy_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: {
+            deepcopy_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+                alloc, rootType,
+                reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(
+                    structExtension),
+                reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_copy_memory_indirect
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
+            deepcopy_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: {
+            deepcopy_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_memory_decompression
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: {
+            deepcopy_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: {
+            deepcopy_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_linear_color_attachment
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
+            deepcopy_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<
+                    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_image_processing
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: {
+            deepcopy_VkImageViewSampleWeightCreateInfoQCOM(
+                alloc, rootType,
+                reinterpret_cast<const VkImageViewSampleWeightCreateInfoQCOM*>(structExtension),
+                reinterpret_cast<VkImageViewSampleWeightCreateInfoQCOM*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
+            deepcopy_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: {
+            deepcopy_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceImageProcessingPropertiesQCOM*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceImageProcessingPropertiesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: {
+            deepcopy_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: {
+            deepcopy_VkRenderPassCreationControlEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkRenderPassCreationControlEXT*>(structExtension),
+                reinterpret_cast<VkRenderPassCreationControlEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+            deepcopy_VkRenderPassCreationFeedbackCreateInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkRenderPassCreationFeedbackCreateInfoEXT*>(structExtension),
+                reinterpret_cast<VkRenderPassCreationFeedbackCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: {
+            deepcopy_VkRenderPassSubpassFeedbackCreateInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkRenderPassSubpassFeedbackCreateInfoEXT*>(structExtension),
+                reinterpret_cast<VkRenderPassSubpassFeedbackCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: {
+            deepcopy_VkDirectDriverLoadingListLUNARG(
+                alloc, rootType,
+                reinterpret_cast<const VkDirectDriverLoadingListLUNARG*>(structExtension),
+                reinterpret_cast<VkDirectDriverLoadingListLUNARG*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_module_identifier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: {
+            deepcopy_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: {
+            deepcopy_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_optical_flow
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
+            deepcopy_VkPhysicalDeviceOpticalFlowFeaturesNV(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceOpticalFlowFeaturesNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: {
+            deepcopy_VkPhysicalDeviceOpticalFlowPropertiesNV(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceOpticalFlowPropertiesNV*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceOpticalFlowPropertiesNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: {
+            deepcopy_VkOpticalFlowImageFormatInfoNV(
+                alloc, rootType,
+                reinterpret_cast<const VkOpticalFlowImageFormatInfoNV*>(structExtension),
+                reinterpret_cast<VkOpticalFlowImageFormatInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: {
+            deepcopy_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+                alloc, rootType,
+                reinterpret_cast<const VkOpticalFlowSessionCreatePrivateDataInfoNV*>(
+                    structExtension),
+                reinterpret_cast<VkOpticalFlowSessionCreatePrivateDataInfoNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_legacy_dithering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: {
+            deepcopy_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_object
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceShaderObjectFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderObjectFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: {
+            deepcopy_VkPhysicalDeviceShaderObjectPropertiesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderObjectPropertiesEXT*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderObjectPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_tile_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
+            deepcopy_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_SEC_amigo_profiling
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
+            deepcopy_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: {
+            deepcopy_VkAmigoProfilingSubmitInfoSEC(
+                alloc, rootType,
+                reinterpret_cast<const VkAmigoProfilingSubmitInfoSEC*>(structExtension),
+                reinterpret_cast<VkAmigoProfilingSubmitInfoSEC*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
+            deepcopy_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: {
+            deepcopy_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
+            deepcopy_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ARM_shader_core_builtins
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
+            deepcopy_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: {
+            deepcopy_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
+            deepcopy_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
+            deepcopy_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: {
+            deepcopy_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+                alloc, rootType,
+                reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(
+                    structExtension),
+                reinterpret_cast<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<
+                    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
             deepcopy_VkWriteDescriptorSetAccelerationStructureKHR(
@@ -21050,6 +26214,22 @@ void deepcopy_extension_struct(Allocator* alloc, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_mesh_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
+            deepcopy_VkPhysicalDeviceMeshShaderFeaturesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: {
+            deepcopy_VkPhysicalDeviceMeshShaderPropertiesEXT(
+                alloc, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesEXT*>(structExtension),
+                reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
         default: {
             return;
         }
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_deepcopy.h b/stream-servers/vulkan/cereal/common/goldfish_vk_deepcopy.h
index 0bb7d537..eb778f5a 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_deepcopy.h
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_deepcopy.h
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_deepcopy
 //
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (header) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -925,6 +925,220 @@ void deepcopy_VkDeviceMemoryOpaqueCaptureAddressInfo(
     VkDeviceMemoryOpaqueCaptureAddressInfo* to);
 
 #endif
+#ifdef VK_VERSION_1_3
+void deepcopy_VkPhysicalDeviceVulkan13Features(Allocator* alloc, VkStructureType rootType,
+                                               const VkPhysicalDeviceVulkan13Features* from,
+                                               VkPhysicalDeviceVulkan13Features* to);
+
+void deepcopy_VkPhysicalDeviceVulkan13Properties(Allocator* alloc, VkStructureType rootType,
+                                                 const VkPhysicalDeviceVulkan13Properties* from,
+                                                 VkPhysicalDeviceVulkan13Properties* to);
+
+void deepcopy_VkPipelineCreationFeedback(Allocator* alloc, VkStructureType rootType,
+                                         const VkPipelineCreationFeedback* from,
+                                         VkPipelineCreationFeedback* to);
+
+void deepcopy_VkPipelineCreationFeedbackCreateInfo(Allocator* alloc, VkStructureType rootType,
+                                                   const VkPipelineCreationFeedbackCreateInfo* from,
+                                                   VkPipelineCreationFeedbackCreateInfo* to);
+
+void deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderTerminateInvocationFeatures* from,
+    VkPhysicalDeviceShaderTerminateInvocationFeatures* to);
+
+void deepcopy_VkPhysicalDeviceToolProperties(Allocator* alloc, VkStructureType rootType,
+                                             const VkPhysicalDeviceToolProperties* from,
+                                             VkPhysicalDeviceToolProperties* to);
+
+void deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* from,
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* to);
+
+void deepcopy_VkPhysicalDevicePrivateDataFeatures(Allocator* alloc, VkStructureType rootType,
+                                                  const VkPhysicalDevicePrivateDataFeatures* from,
+                                                  VkPhysicalDevicePrivateDataFeatures* to);
+
+void deepcopy_VkDevicePrivateDataCreateInfo(Allocator* alloc, VkStructureType rootType,
+                                            const VkDevicePrivateDataCreateInfo* from,
+                                            VkDevicePrivateDataCreateInfo* to);
+
+void deepcopy_VkPrivateDataSlotCreateInfo(Allocator* alloc, VkStructureType rootType,
+                                          const VkPrivateDataSlotCreateInfo* from,
+                                          VkPrivateDataSlotCreateInfo* to);
+
+void deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePipelineCreationCacheControlFeatures* from,
+    VkPhysicalDevicePipelineCreationCacheControlFeatures* to);
+
+void deepcopy_VkMemoryBarrier2(Allocator* alloc, VkStructureType rootType,
+                               const VkMemoryBarrier2* from, VkMemoryBarrier2* to);
+
+void deepcopy_VkBufferMemoryBarrier2(Allocator* alloc, VkStructureType rootType,
+                                     const VkBufferMemoryBarrier2* from,
+                                     VkBufferMemoryBarrier2* to);
+
+void deepcopy_VkImageMemoryBarrier2(Allocator* alloc, VkStructureType rootType,
+                                    const VkImageMemoryBarrier2* from, VkImageMemoryBarrier2* to);
+
+void deepcopy_VkDependencyInfo(Allocator* alloc, VkStructureType rootType,
+                               const VkDependencyInfo* from, VkDependencyInfo* to);
+
+void deepcopy_VkSemaphoreSubmitInfo(Allocator* alloc, VkStructureType rootType,
+                                    const VkSemaphoreSubmitInfo* from, VkSemaphoreSubmitInfo* to);
+
+void deepcopy_VkCommandBufferSubmitInfo(Allocator* alloc, VkStructureType rootType,
+                                        const VkCommandBufferSubmitInfo* from,
+                                        VkCommandBufferSubmitInfo* to);
+
+void deepcopy_VkSubmitInfo2(Allocator* alloc, VkStructureType rootType, const VkSubmitInfo2* from,
+                            VkSubmitInfo2* to);
+
+void deepcopy_VkPhysicalDeviceSynchronization2Features(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceSynchronization2Features* from,
+    VkPhysicalDeviceSynchronization2Features* to);
+
+void deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* from,
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* to);
+
+void deepcopy_VkPhysicalDeviceImageRobustnessFeatures(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceImageRobustnessFeatures* from,
+    VkPhysicalDeviceImageRobustnessFeatures* to);
+
+void deepcopy_VkBufferCopy2(Allocator* alloc, VkStructureType rootType, const VkBufferCopy2* from,
+                            VkBufferCopy2* to);
+
+void deepcopy_VkCopyBufferInfo2(Allocator* alloc, VkStructureType rootType,
+                                const VkCopyBufferInfo2* from, VkCopyBufferInfo2* to);
+
+void deepcopy_VkImageCopy2(Allocator* alloc, VkStructureType rootType, const VkImageCopy2* from,
+                           VkImageCopy2* to);
+
+void deepcopy_VkCopyImageInfo2(Allocator* alloc, VkStructureType rootType,
+                               const VkCopyImageInfo2* from, VkCopyImageInfo2* to);
+
+void deepcopy_VkBufferImageCopy2(Allocator* alloc, VkStructureType rootType,
+                                 const VkBufferImageCopy2* from, VkBufferImageCopy2* to);
+
+void deepcopy_VkCopyBufferToImageInfo2(Allocator* alloc, VkStructureType rootType,
+                                       const VkCopyBufferToImageInfo2* from,
+                                       VkCopyBufferToImageInfo2* to);
+
+void deepcopy_VkCopyImageToBufferInfo2(Allocator* alloc, VkStructureType rootType,
+                                       const VkCopyImageToBufferInfo2* from,
+                                       VkCopyImageToBufferInfo2* to);
+
+void deepcopy_VkImageBlit2(Allocator* alloc, VkStructureType rootType, const VkImageBlit2* from,
+                           VkImageBlit2* to);
+
+void deepcopy_VkBlitImageInfo2(Allocator* alloc, VkStructureType rootType,
+                               const VkBlitImageInfo2* from, VkBlitImageInfo2* to);
+
+void deepcopy_VkImageResolve2(Allocator* alloc, VkStructureType rootType,
+                              const VkImageResolve2* from, VkImageResolve2* to);
+
+void deepcopy_VkResolveImageInfo2(Allocator* alloc, VkStructureType rootType,
+                                  const VkResolveImageInfo2* from, VkResolveImageInfo2* to);
+
+void deepcopy_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceSubgroupSizeControlFeatures* from,
+    VkPhysicalDeviceSubgroupSizeControlFeatures* to);
+
+void deepcopy_VkPhysicalDeviceSubgroupSizeControlProperties(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceSubgroupSizeControlProperties* from,
+    VkPhysicalDeviceSubgroupSizeControlProperties* to);
+
+void deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* from,
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* to);
+
+void deepcopy_VkPhysicalDeviceInlineUniformBlockFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceInlineUniformBlockFeatures* from,
+    VkPhysicalDeviceInlineUniformBlockFeatures* to);
+
+void deepcopy_VkPhysicalDeviceInlineUniformBlockProperties(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceInlineUniformBlockProperties* from,
+    VkPhysicalDeviceInlineUniformBlockProperties* to);
+
+void deepcopy_VkWriteDescriptorSetInlineUniformBlock(
+    Allocator* alloc, VkStructureType rootType, const VkWriteDescriptorSetInlineUniformBlock* from,
+    VkWriteDescriptorSetInlineUniformBlock* to);
+
+void deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    Allocator* alloc, VkStructureType rootType,
+    const VkDescriptorPoolInlineUniformBlockCreateInfo* from,
+    VkDescriptorPoolInlineUniformBlockCreateInfo* to);
+
+void deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* from,
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* to);
+
+void deepcopy_VkRenderingAttachmentInfo(Allocator* alloc, VkStructureType rootType,
+                                        const VkRenderingAttachmentInfo* from,
+                                        VkRenderingAttachmentInfo* to);
+
+void deepcopy_VkRenderingInfo(Allocator* alloc, VkStructureType rootType,
+                              const VkRenderingInfo* from, VkRenderingInfo* to);
+
+void deepcopy_VkPipelineRenderingCreateInfo(Allocator* alloc, VkStructureType rootType,
+                                            const VkPipelineRenderingCreateInfo* from,
+                                            VkPipelineRenderingCreateInfo* to);
+
+void deepcopy_VkPhysicalDeviceDynamicRenderingFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDynamicRenderingFeatures* from,
+    VkPhysicalDeviceDynamicRenderingFeatures* to);
+
+void deepcopy_VkCommandBufferInheritanceRenderingInfo(
+    Allocator* alloc, VkStructureType rootType, const VkCommandBufferInheritanceRenderingInfo* from,
+    VkCommandBufferInheritanceRenderingInfo* to);
+
+void deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderIntegerDotProductFeatures* from,
+    VkPhysicalDeviceShaderIntegerDotProductFeatures* to);
+
+void deepcopy_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderIntegerDotProductProperties* from,
+    VkPhysicalDeviceShaderIntegerDotProductProperties* to);
+
+void deepcopy_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceTexelBufferAlignmentProperties* from,
+    VkPhysicalDeviceTexelBufferAlignmentProperties* to);
+
+void deepcopy_VkFormatProperties3(Allocator* alloc, VkStructureType rootType,
+                                  const VkFormatProperties3* from, VkFormatProperties3* to);
+
+void deepcopy_VkPhysicalDeviceMaintenance4Features(Allocator* alloc, VkStructureType rootType,
+                                                   const VkPhysicalDeviceMaintenance4Features* from,
+                                                   VkPhysicalDeviceMaintenance4Features* to);
+
+void deepcopy_VkPhysicalDeviceMaintenance4Properties(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance4Properties* from,
+    VkPhysicalDeviceMaintenance4Properties* to);
+
+void deepcopy_VkDeviceBufferMemoryRequirements(Allocator* alloc, VkStructureType rootType,
+                                               const VkDeviceBufferMemoryRequirements* from,
+                                               VkDeviceBufferMemoryRequirements* to);
+
+void deepcopy_VkDeviceImageMemoryRequirements(Allocator* alloc, VkStructureType rootType,
+                                              const VkDeviceImageMemoryRequirements* from,
+                                              VkDeviceImageMemoryRequirements* to);
+
+#endif
 #ifdef VK_KHR_surface
 void deepcopy_VkSurfaceCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
                                        const VkSurfaceCapabilitiesKHR* from,
@@ -1036,15 +1250,21 @@ void deepcopy_VkWin32SurfaceCreateInfoKHR(Allocator* alloc, VkStructureType root
 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
 #endif
 #ifdef VK_KHR_video_queue
-void deepcopy_VkVideoQueueFamilyProperties2KHR(Allocator* alloc, VkStructureType rootType,
-                                               const VkVideoQueueFamilyProperties2KHR* from,
-                                               VkVideoQueueFamilyProperties2KHR* to);
+void deepcopy_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkQueueFamilyQueryResultStatusPropertiesKHR* from,
+    VkQueueFamilyQueryResultStatusPropertiesKHR* to);
 
-void deepcopy_VkVideoProfileKHR(Allocator* alloc, VkStructureType rootType,
-                                const VkVideoProfileKHR* from, VkVideoProfileKHR* to);
+void deepcopy_VkQueueFamilyVideoPropertiesKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkQueueFamilyVideoPropertiesKHR* from,
+                                              VkQueueFamilyVideoPropertiesKHR* to);
 
-void deepcopy_VkVideoProfilesKHR(Allocator* alloc, VkStructureType rootType,
-                                 const VkVideoProfilesKHR* from, VkVideoProfilesKHR* to);
+void deepcopy_VkVideoProfileInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                    const VkVideoProfileInfoKHR* from, VkVideoProfileInfoKHR* to);
+
+void deepcopy_VkVideoProfileListInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                        const VkVideoProfileListInfoKHR* from,
+                                        VkVideoProfileListInfoKHR* to);
 
 void deepcopy_VkVideoCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
                                      const VkVideoCapabilitiesKHR* from,
@@ -1058,20 +1278,21 @@ void deepcopy_VkVideoFormatPropertiesKHR(Allocator* alloc, VkStructureType rootT
                                          const VkVideoFormatPropertiesKHR* from,
                                          VkVideoFormatPropertiesKHR* to);
 
-void deepcopy_VkVideoPictureResourceKHR(Allocator* alloc, VkStructureType rootType,
-                                        const VkVideoPictureResourceKHR* from,
-                                        VkVideoPictureResourceKHR* to);
+void deepcopy_VkVideoPictureResourceInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                            const VkVideoPictureResourceInfoKHR* from,
+                                            VkVideoPictureResourceInfoKHR* to);
 
-void deepcopy_VkVideoReferenceSlotKHR(Allocator* alloc, VkStructureType rootType,
-                                      const VkVideoReferenceSlotKHR* from,
-                                      VkVideoReferenceSlotKHR* to);
+void deepcopy_VkVideoReferenceSlotInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                          const VkVideoReferenceSlotInfoKHR* from,
+                                          VkVideoReferenceSlotInfoKHR* to);
 
-void deepcopy_VkVideoGetMemoryPropertiesKHR(Allocator* alloc, VkStructureType rootType,
-                                            const VkVideoGetMemoryPropertiesKHR* from,
-                                            VkVideoGetMemoryPropertiesKHR* to);
+void deepcopy_VkVideoSessionMemoryRequirementsKHR(Allocator* alloc, VkStructureType rootType,
+                                                  const VkVideoSessionMemoryRequirementsKHR* from,
+                                                  VkVideoSessionMemoryRequirementsKHR* to);
 
-void deepcopy_VkVideoBindMemoryKHR(Allocator* alloc, VkStructureType rootType,
-                                   const VkVideoBindMemoryKHR* from, VkVideoBindMemoryKHR* to);
+void deepcopy_VkBindVideoSessionMemoryInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkBindVideoSessionMemoryInfoKHR* from,
+                                              VkBindVideoSessionMemoryInfoKHR* to);
 
 void deepcopy_VkVideoSessionCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
                                           const VkVideoSessionCreateInfoKHR* from,
@@ -1099,31 +1320,59 @@ void deepcopy_VkVideoCodingControlInfoKHR(Allocator* alloc, VkStructureType root
 
 #endif
 #ifdef VK_KHR_video_decode_queue
+void deepcopy_VkVideoDecodeCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+                                           const VkVideoDecodeCapabilitiesKHR* from,
+                                           VkVideoDecodeCapabilitiesKHR* to);
+
+void deepcopy_VkVideoDecodeUsageInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                        const VkVideoDecodeUsageInfoKHR* from,
+                                        VkVideoDecodeUsageInfoKHR* to);
+
 void deepcopy_VkVideoDecodeInfoKHR(Allocator* alloc, VkStructureType rootType,
                                    const VkVideoDecodeInfoKHR* from, VkVideoDecodeInfoKHR* to);
 
 #endif
-#ifdef VK_KHR_dynamic_rendering
-void deepcopy_VkRenderingAttachmentInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                           const VkRenderingAttachmentInfoKHR* from,
-                                           VkRenderingAttachmentInfoKHR* to);
+#ifdef VK_KHR_video_decode_h264
+void deepcopy_VkVideoDecodeH264ProfileInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoDecodeH264ProfileInfoKHR* from,
+                                              VkVideoDecodeH264ProfileInfoKHR* to);
 
-void deepcopy_VkRenderingInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                 const VkRenderingInfoKHR* from, VkRenderingInfoKHR* to);
+void deepcopy_VkVideoDecodeH264CapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+                                               const VkVideoDecodeH264CapabilitiesKHR* from,
+                                               VkVideoDecodeH264CapabilitiesKHR* to);
 
-void deepcopy_VkPipelineRenderingCreateInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                               const VkPipelineRenderingCreateInfoKHR* from,
-                                               VkPipelineRenderingCreateInfoKHR* to);
-
-void deepcopy_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+void deepcopy_VkVideoDecodeH264SessionParametersAddInfoKHR(
     Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceDynamicRenderingFeaturesKHR* from,
-    VkPhysicalDeviceDynamicRenderingFeaturesKHR* to);
+    const VkVideoDecodeH264SessionParametersAddInfoKHR* from,
+    VkVideoDecodeH264SessionParametersAddInfoKHR* to);
 
-void deepcopy_VkCommandBufferInheritanceRenderingInfoKHR(
+void deepcopy_VkVideoDecodeH264SessionParametersCreateInfoKHR(
     Allocator* alloc, VkStructureType rootType,
-    const VkCommandBufferInheritanceRenderingInfoKHR* from,
-    VkCommandBufferInheritanceRenderingInfoKHR* to);
+    const VkVideoDecodeH264SessionParametersCreateInfoKHR* from,
+    VkVideoDecodeH264SessionParametersCreateInfoKHR* to);
+
+void deepcopy_VkVideoDecodeH264PictureInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoDecodeH264PictureInfoKHR* from,
+                                              VkVideoDecodeH264PictureInfoKHR* to);
+
+void deepcopy_VkVideoDecodeH264DpbSlotInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoDecodeH264DpbSlotInfoKHR* from,
+                                              VkVideoDecodeH264DpbSlotInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_dynamic_rendering
+DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderingInfo, deepcopy_VkRenderingInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(deepcopy_VkRenderingAttachmentInfo, deepcopy_VkRenderingAttachmentInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineRenderingCreateInfo,
+                      deepcopy_VkPipelineRenderingCreateInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceDynamicRenderingFeatures,
+                      deepcopy_VkPhysicalDeviceDynamicRenderingFeaturesKHR)
+
+DEFINE_ALIAS_FUNCTION(deepcopy_VkCommandBufferInheritanceRenderingInfo,
+                      deepcopy_VkCommandBufferInheritanceRenderingInfoKHR)
 
 void deepcopy_VkRenderingFragmentShadingRateAttachmentInfoKHR(
     Allocator* alloc, VkStructureType rootType,
@@ -1623,6 +1872,51 @@ void deepcopy_VkPhysicalDeviceShaderClockFeaturesKHR(
     VkPhysicalDeviceShaderClockFeaturesKHR* to);
 
 #endif
+#ifdef VK_KHR_video_decode_h265
+void deepcopy_VkVideoDecodeH265ProfileInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoDecodeH265ProfileInfoKHR* from,
+                                              VkVideoDecodeH265ProfileInfoKHR* to);
+
+void deepcopy_VkVideoDecodeH265CapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+                                               const VkVideoDecodeH265CapabilitiesKHR* from,
+                                               VkVideoDecodeH265CapabilitiesKHR* to);
+
+void deepcopy_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkVideoDecodeH265SessionParametersAddInfoKHR* from,
+    VkVideoDecodeH265SessionParametersAddInfoKHR* to);
+
+void deepcopy_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkVideoDecodeH265SessionParametersCreateInfoKHR* from,
+    VkVideoDecodeH265SessionParametersCreateInfoKHR* to);
+
+void deepcopy_VkVideoDecodeH265PictureInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoDecodeH265PictureInfoKHR* from,
+                                              VkVideoDecodeH265PictureInfoKHR* to);
+
+void deepcopy_VkVideoDecodeH265DpbSlotInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoDecodeH265DpbSlotInfoKHR* from,
+                                              VkVideoDecodeH265DpbSlotInfoKHR* to);
+
+#endif
+#ifdef VK_KHR_global_priority
+void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkDeviceQueueGlobalPriorityCreateInfoKHR* from,
+    VkDeviceQueueGlobalPriorityCreateInfoKHR* to);
+
+void deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* from,
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* to);
+
+void deepcopy_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkQueueFamilyGlobalPriorityPropertiesKHR* from,
+    VkQueueFamilyGlobalPriorityPropertiesKHR* to);
+
+#endif
 #ifdef VK_KHR_driver_properties
 DEFINE_ALIAS_FUNCTION(deepcopy_VkConformanceVersion, deepcopy_VkConformanceVersionKHR)
 
@@ -1668,10 +1962,8 @@ DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceVulkanMemoryModelFeatures,
 
 #endif
 #ifdef VK_KHR_shader_terminate_invocation
-void deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* from,
-    VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeatures,
+                      deepcopy_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)
 
 #endif
 #ifdef VK_KHR_fragment_shading_rate
@@ -1778,16 +2070,20 @@ void deepcopy_VkPipelineExecutableInternalRepresentationKHR(
     VkPipelineExecutableInternalRepresentationKHR* to);
 
 #endif
+#ifdef VK_KHR_map_memory2
+void deepcopy_VkMemoryMapInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                 const VkMemoryMapInfoKHR* from, VkMemoryMapInfoKHR* to);
+
+void deepcopy_VkMemoryUnmapInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                   const VkMemoryUnmapInfoKHR* from, VkMemoryUnmapInfoKHR* to);
+
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
-void deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* from,
-    VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeatures,
+                      deepcopy_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR)
 
-void deepcopy_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* from,
-    VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderIntegerDotProductProperties,
+                      deepcopy_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)
 
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -1811,41 +2107,45 @@ void deepcopy_VkPhysicalDevicePresentIdFeaturesKHR(Allocator* alloc, VkStructure
 void deepcopy_VkVideoEncodeInfoKHR(Allocator* alloc, VkStructureType rootType,
                                    const VkVideoEncodeInfoKHR* from, VkVideoEncodeInfoKHR* to);
 
+void deepcopy_VkVideoEncodeCapabilitiesKHR(Allocator* alloc, VkStructureType rootType,
+                                           const VkVideoEncodeCapabilitiesKHR* from,
+                                           VkVideoEncodeCapabilitiesKHR* to);
+
+void deepcopy_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* from,
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* to);
+
+void deepcopy_VkVideoEncodeUsageInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                        const VkVideoEncodeUsageInfoKHR* from,
+                                        VkVideoEncodeUsageInfoKHR* to);
+
+void deepcopy_VkVideoEncodeRateControlLayerInfoKHR(Allocator* alloc, VkStructureType rootType,
+                                                   const VkVideoEncodeRateControlLayerInfoKHR* from,
+                                                   VkVideoEncodeRateControlLayerInfoKHR* to);
+
 void deepcopy_VkVideoEncodeRateControlInfoKHR(Allocator* alloc, VkStructureType rootType,
                                               const VkVideoEncodeRateControlInfoKHR* from,
                                               VkVideoEncodeRateControlInfoKHR* to);
 
 #endif
 #ifdef VK_KHR_synchronization2
-void deepcopy_VkMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootType,
-                                  const VkMemoryBarrier2KHR* from, VkMemoryBarrier2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkMemoryBarrier2, deepcopy_VkMemoryBarrier2KHR)
 
-void deepcopy_VkBufferMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootType,
-                                        const VkBufferMemoryBarrier2KHR* from,
-                                        VkBufferMemoryBarrier2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferMemoryBarrier2, deepcopy_VkBufferMemoryBarrier2KHR)
 
-void deepcopy_VkImageMemoryBarrier2KHR(Allocator* alloc, VkStructureType rootType,
-                                       const VkImageMemoryBarrier2KHR* from,
-                                       VkImageMemoryBarrier2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkImageMemoryBarrier2, deepcopy_VkImageMemoryBarrier2KHR)
 
-void deepcopy_VkDependencyInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                  const VkDependencyInfoKHR* from, VkDependencyInfoKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDependencyInfo, deepcopy_VkDependencyInfoKHR)
 
-void deepcopy_VkSemaphoreSubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                       const VkSemaphoreSubmitInfoKHR* from,
-                                       VkSemaphoreSubmitInfoKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkSubmitInfo2, deepcopy_VkSubmitInfo2KHR)
 
-void deepcopy_VkCommandBufferSubmitInfoKHR(Allocator* alloc, VkStructureType rootType,
-                                           const VkCommandBufferSubmitInfoKHR* from,
-                                           VkCommandBufferSubmitInfoKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkSemaphoreSubmitInfo, deepcopy_VkSemaphoreSubmitInfoKHR)
 
-void deepcopy_VkSubmitInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                               const VkSubmitInfo2KHR* from, VkSubmitInfo2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkCommandBufferSubmitInfo, deepcopy_VkCommandBufferSubmitInfoKHR)
 
-void deepcopy_VkPhysicalDeviceSynchronization2FeaturesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceSynchronization2FeaturesKHR* from,
-    VkPhysicalDeviceSynchronization2FeaturesKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSynchronization2Features,
+                      deepcopy_VkPhysicalDeviceSynchronization2FeaturesKHR)
 
 void deepcopy_VkQueueFamilyCheckpointProperties2NV(Allocator* alloc, VkStructureType rootType,
                                                    const VkQueueFamilyCheckpointProperties2NV* from,
@@ -1855,6 +2155,18 @@ void deepcopy_VkCheckpointData2NV(Allocator* alloc, VkStructureType rootType,
                                   const VkCheckpointData2NV* from, VkCheckpointData2NV* to);
 
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+void deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* from,
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* to);
+
+void deepcopy_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* from,
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* to);
+
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 void deepcopy_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
     Allocator* alloc, VkStructureType rootType,
@@ -1863,10 +2175,8 @@ void deepcopy_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
-void deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* from,
-    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
+                      deepcopy_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR)
 
 #endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
@@ -1877,72 +2187,84 @@ void deepcopy_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_copy_commands2
-void deepcopy_VkBufferCopy2KHR(Allocator* alloc, VkStructureType rootType,
-                               const VkBufferCopy2KHR* from, VkBufferCopy2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkCopyBufferInfo2, deepcopy_VkCopyBufferInfo2KHR)
 
-void deepcopy_VkCopyBufferInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                                   const VkCopyBufferInfo2KHR* from, VkCopyBufferInfo2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkCopyImageInfo2, deepcopy_VkCopyImageInfo2KHR)
 
-void deepcopy_VkImageCopy2KHR(Allocator* alloc, VkStructureType rootType,
-                              const VkImageCopy2KHR* from, VkImageCopy2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkCopyBufferToImageInfo2, deepcopy_VkCopyBufferToImageInfo2KHR)
 
-void deepcopy_VkCopyImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                                  const VkCopyImageInfo2KHR* from, VkCopyImageInfo2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkCopyImageToBufferInfo2, deepcopy_VkCopyImageToBufferInfo2KHR)
 
-void deepcopy_VkBufferImageCopy2KHR(Allocator* alloc, VkStructureType rootType,
-                                    const VkBufferImageCopy2KHR* from, VkBufferImageCopy2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkBlitImageInfo2, deepcopy_VkBlitImageInfo2KHR)
 
-void deepcopy_VkCopyBufferToImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                                          const VkCopyBufferToImageInfo2KHR* from,
-                                          VkCopyBufferToImageInfo2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkResolveImageInfo2, deepcopy_VkResolveImageInfo2KHR)
 
-void deepcopy_VkCopyImageToBufferInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                                          const VkCopyImageToBufferInfo2KHR* from,
-                                          VkCopyImageToBufferInfo2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferCopy2, deepcopy_VkBufferCopy2KHR)
 
-void deepcopy_VkImageBlit2KHR(Allocator* alloc, VkStructureType rootType,
-                              const VkImageBlit2KHR* from, VkImageBlit2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkImageCopy2, deepcopy_VkImageCopy2KHR)
 
-void deepcopy_VkBlitImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                                  const VkBlitImageInfo2KHR* from, VkBlitImageInfo2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkImageBlit2, deepcopy_VkImageBlit2KHR)
 
-void deepcopy_VkImageResolve2KHR(Allocator* alloc, VkStructureType rootType,
-                                 const VkImageResolve2KHR* from, VkImageResolve2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkBufferImageCopy2, deepcopy_VkBufferImageCopy2KHR)
 
-void deepcopy_VkResolveImageInfo2KHR(Allocator* alloc, VkStructureType rootType,
-                                     const VkResolveImageInfo2KHR* from,
-                                     VkResolveImageInfo2KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkImageResolve2, deepcopy_VkImageResolve2KHR)
 
 #endif
 #ifdef VK_KHR_format_feature_flags2
-void deepcopy_VkFormatProperties3KHR(Allocator* alloc, VkStructureType rootType,
-                                     const VkFormatProperties3KHR* from,
-                                     VkFormatProperties3KHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkFormatProperties3, deepcopy_VkFormatProperties3KHR)
 
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+void deepcopy_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* from,
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* to);
+
+void deepcopy_VkTraceRaysIndirectCommand2KHR(Allocator* alloc, VkStructureType rootType,
+                                             const VkTraceRaysIndirectCommand2KHR* from,
+                                             VkTraceRaysIndirectCommand2KHR* to);
+
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
-void deepcopy_VkPhysicalDeviceMaintenance4FeaturesKHR(
-    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMaintenance4FeaturesKHR* from,
-    VkPhysicalDeviceMaintenance4FeaturesKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMaintenance4Features,
+                      deepcopy_VkPhysicalDeviceMaintenance4FeaturesKHR)
 
-void deepcopy_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceMaintenance4PropertiesKHR* from,
-    VkPhysicalDeviceMaintenance4PropertiesKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMaintenance4Properties,
+                      deepcopy_VkPhysicalDeviceMaintenance4PropertiesKHR)
+
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceBufferMemoryRequirements,
+                      deepcopy_VkDeviceBufferMemoryRequirementsKHR)
 
-void deepcopy_VkDeviceBufferMemoryRequirementsKHR(Allocator* alloc, VkStructureType rootType,
-                                                  const VkDeviceBufferMemoryRequirementsKHR* from,
-                                                  VkDeviceBufferMemoryRequirementsKHR* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceImageMemoryRequirements,
+                      deepcopy_VkDeviceImageMemoryRequirementsKHR)
 
-void deepcopy_VkDeviceImageMemoryRequirementsKHR(Allocator* alloc, VkStructureType rootType,
-                                                 const VkDeviceImageMemoryRequirementsKHR* from,
-                                                 VkDeviceImageMemoryRequirementsKHR* to);
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+void deepcopy_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* from,
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* to);
 
 #endif
 #ifdef VK_ANDROID_native_buffer
+void deepcopy_VkNativeBufferUsage2ANDROID(Allocator* alloc, VkStructureType rootType,
+                                          const VkNativeBufferUsage2ANDROID* from,
+                                          VkNativeBufferUsage2ANDROID* to);
+
 void deepcopy_VkNativeBufferANDROID(Allocator* alloc, VkStructureType rootType,
                                     const VkNativeBufferANDROID* from, VkNativeBufferANDROID* to);
 
+void deepcopy_VkSwapchainImageCreateInfoANDROID(Allocator* alloc, VkStructureType rootType,
+                                                const VkSwapchainImageCreateInfoANDROID* from,
+                                                VkSwapchainImageCreateInfoANDROID* to);
+
+void deepcopy_VkPhysicalDevicePresentationPropertiesANDROID(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePresentationPropertiesANDROID* from,
+    VkPhysicalDevicePresentationPropertiesANDROID* to);
+
 #endif
 #ifdef VK_EXT_debug_report
 void deepcopy_VkDebugReportCallbackCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
@@ -2051,10 +2373,6 @@ void deepcopy_VkVideoEncodeH264CapabilitiesEXT(Allocator* alloc, VkStructureType
                                                const VkVideoEncodeH264CapabilitiesEXT* from,
                                                VkVideoEncodeH264CapabilitiesEXT* to);
 
-void deepcopy_VkVideoEncodeH264SessionCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType, const VkVideoEncodeH264SessionCreateInfoEXT* from,
-    VkVideoEncodeH264SessionCreateInfoEXT* to);
-
 void deepcopy_VkVideoEncodeH264SessionParametersAddInfoEXT(
     Allocator* alloc, VkStructureType rootType,
     const VkVideoEncodeH264SessionParametersAddInfoEXT* from,
@@ -2065,26 +2383,38 @@ void deepcopy_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     const VkVideoEncodeH264SessionParametersCreateInfoEXT* from,
     VkVideoEncodeH264SessionParametersCreateInfoEXT* to);
 
+void deepcopy_VkVideoEncodeH264NaluSliceInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                const VkVideoEncodeH264NaluSliceInfoEXT* from,
+                                                VkVideoEncodeH264NaluSliceInfoEXT* to);
+
+void deepcopy_VkVideoEncodeH264VclFrameInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                               const VkVideoEncodeH264VclFrameInfoEXT* from,
+                                               VkVideoEncodeH264VclFrameInfoEXT* to);
+
 void deepcopy_VkVideoEncodeH264DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
                                               const VkVideoEncodeH264DpbSlotInfoEXT* from,
                                               VkVideoEncodeH264DpbSlotInfoEXT* to);
 
-void deepcopy_VkVideoEncodeH264NaluSliceEXT(Allocator* alloc, VkStructureType rootType,
-                                            const VkVideoEncodeH264NaluSliceEXT* from,
-                                            VkVideoEncodeH264NaluSliceEXT* to);
+void deepcopy_VkVideoEncodeH264ProfileInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoEncodeH264ProfileInfoEXT* from,
+                                              VkVideoEncodeH264ProfileInfoEXT* to);
 
-void deepcopy_VkVideoEncodeH264VclFrameInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                               const VkVideoEncodeH264VclFrameInfoEXT* from,
-                                               VkVideoEncodeH264VclFrameInfoEXT* to);
+void deepcopy_VkVideoEncodeH264RateControlInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                  const VkVideoEncodeH264RateControlInfoEXT* from,
+                                                  VkVideoEncodeH264RateControlInfoEXT* to);
 
-void deepcopy_VkVideoEncodeH264EmitPictureParametersEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkVideoEncodeH264EmitPictureParametersEXT* from,
-    VkVideoEncodeH264EmitPictureParametersEXT* to);
+void deepcopy_VkVideoEncodeH264QpEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkVideoEncodeH264QpEXT* from,
+                                     VkVideoEncodeH264QpEXT* to);
 
-void deepcopy_VkVideoEncodeH264ProfileEXT(Allocator* alloc, VkStructureType rootType,
-                                          const VkVideoEncodeH264ProfileEXT* from,
-                                          VkVideoEncodeH264ProfileEXT* to);
+void deepcopy_VkVideoEncodeH264FrameSizeEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkVideoEncodeH264FrameSizeEXT* from,
+                                            VkVideoEncodeH264FrameSizeEXT* to);
+
+void deepcopy_VkVideoEncodeH264RateControlLayerInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkVideoEncodeH264RateControlLayerInfoEXT* from,
+    VkVideoEncodeH264RateControlLayerInfoEXT* to);
 
 #endif
 #ifdef VK_EXT_video_encode_h265
@@ -2092,10 +2422,6 @@ void deepcopy_VkVideoEncodeH265CapabilitiesEXT(Allocator* alloc, VkStructureType
                                                const VkVideoEncodeH265CapabilitiesEXT* from,
                                                VkVideoEncodeH265CapabilitiesEXT* to);
 
-void deepcopy_VkVideoEncodeH265SessionCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType, const VkVideoEncodeH265SessionCreateInfoEXT* from,
-    VkVideoEncodeH265SessionCreateInfoEXT* to);
-
 void deepcopy_VkVideoEncodeH265SessionParametersAddInfoEXT(
     Allocator* alloc, VkStructureType rootType,
     const VkVideoEncodeH265SessionParametersAddInfoEXT* from,
@@ -2106,66 +2432,39 @@ void deepcopy_VkVideoEncodeH265SessionParametersCreateInfoEXT(
     const VkVideoEncodeH265SessionParametersCreateInfoEXT* from,
     VkVideoEncodeH265SessionParametersCreateInfoEXT* to);
 
-void deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                              const VkVideoEncodeH265DpbSlotInfoEXT* from,
-                                              VkVideoEncodeH265DpbSlotInfoEXT* to);
-
-void deepcopy_VkVideoEncodeH265ReferenceListsEXT(Allocator* alloc, VkStructureType rootType,
-                                                 const VkVideoEncodeH265ReferenceListsEXT* from,
-                                                 VkVideoEncodeH265ReferenceListsEXT* to);
-
-void deepcopy_VkVideoEncodeH265NaluSliceEXT(Allocator* alloc, VkStructureType rootType,
-                                            const VkVideoEncodeH265NaluSliceEXT* from,
-                                            VkVideoEncodeH265NaluSliceEXT* to);
+void deepcopy_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkVideoEncodeH265NaluSliceSegmentInfoEXT* from,
+    VkVideoEncodeH265NaluSliceSegmentInfoEXT* to);
 
 void deepcopy_VkVideoEncodeH265VclFrameInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                const VkVideoEncodeH265VclFrameInfoEXT* from,
                                                VkVideoEncodeH265VclFrameInfoEXT* to);
 
-void deepcopy_VkVideoEncodeH265EmitPictureParametersEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkVideoEncodeH265EmitPictureParametersEXT* from,
-    VkVideoEncodeH265EmitPictureParametersEXT* to);
-
-void deepcopy_VkVideoEncodeH265ProfileEXT(Allocator* alloc, VkStructureType rootType,
-                                          const VkVideoEncodeH265ProfileEXT* from,
-                                          VkVideoEncodeH265ProfileEXT* to);
+void deepcopy_VkVideoEncodeH265DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoEncodeH265DpbSlotInfoEXT* from,
+                                              VkVideoEncodeH265DpbSlotInfoEXT* to);
 
-#endif
-#ifdef VK_EXT_video_decode_h264
-void deepcopy_VkVideoDecodeH264ProfileEXT(Allocator* alloc, VkStructureType rootType,
-                                          const VkVideoDecodeH264ProfileEXT* from,
-                                          VkVideoDecodeH264ProfileEXT* to);
+void deepcopy_VkVideoEncodeH265ProfileInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkVideoEncodeH265ProfileInfoEXT* from,
+                                              VkVideoEncodeH265ProfileInfoEXT* to);
 
-void deepcopy_VkVideoDecodeH264CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
-                                               const VkVideoDecodeH264CapabilitiesEXT* from,
-                                               VkVideoDecodeH264CapabilitiesEXT* to);
+void deepcopy_VkVideoEncodeH265RateControlInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                  const VkVideoEncodeH265RateControlInfoEXT* from,
+                                                  VkVideoEncodeH265RateControlInfoEXT* to);
 
-void deepcopy_VkVideoDecodeH264SessionCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType, const VkVideoDecodeH264SessionCreateInfoEXT* from,
-    VkVideoDecodeH264SessionCreateInfoEXT* to);
+void deepcopy_VkVideoEncodeH265QpEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkVideoEncodeH265QpEXT* from,
+                                     VkVideoEncodeH265QpEXT* to);
 
-void deepcopy_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkVideoDecodeH264SessionParametersAddInfoEXT* from,
-    VkVideoDecodeH264SessionParametersAddInfoEXT* to);
+void deepcopy_VkVideoEncodeH265FrameSizeEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkVideoEncodeH265FrameSizeEXT* from,
+                                            VkVideoEncodeH265FrameSizeEXT* to);
 
-void deepcopy_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+void deepcopy_VkVideoEncodeH265RateControlLayerInfoEXT(
     Allocator* alloc, VkStructureType rootType,
-    const VkVideoDecodeH264SessionParametersCreateInfoEXT* from,
-    VkVideoDecodeH264SessionParametersCreateInfoEXT* to);
-
-void deepcopy_VkVideoDecodeH264PictureInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                              const VkVideoDecodeH264PictureInfoEXT* from,
-                                              VkVideoDecodeH264PictureInfoEXT* to);
-
-void deepcopy_VkVideoDecodeH264MvcEXT(Allocator* alloc, VkStructureType rootType,
-                                      const VkVideoDecodeH264MvcEXT* from,
-                                      VkVideoDecodeH264MvcEXT* to);
-
-void deepcopy_VkVideoDecodeH264DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                              const VkVideoDecodeH264DpbSlotInfoEXT* from,
-                                              VkVideoDecodeH264DpbSlotInfoEXT* to);
+    const VkVideoEncodeH265RateControlLayerInfoEXT* from,
+    VkVideoEncodeH265RateControlLayerInfoEXT* to);
 
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
@@ -2249,10 +2548,8 @@ void deepcopy_VkViSurfaceCreateInfoNN(Allocator* alloc, VkStructureType rootType
 #ifdef VK_EXT_shader_subgroup_vote
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
-void deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* from,
-    VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeatures,
+                      deepcopy_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
 
 #endif
 #ifdef VK_EXT_astc_decode_mode
@@ -2265,6 +2562,22 @@ void deepcopy_VkPhysicalDeviceASTCDecodeFeaturesEXT(
     VkPhysicalDeviceASTCDecodeFeaturesEXT* to);
 
 #endif
+#ifdef VK_EXT_pipeline_robustness
+void deepcopy_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* from,
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT* to);
+
+void deepcopy_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* from,
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT* to);
+
+void deepcopy_VkPipelineRobustnessCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                const VkPipelineRobustnessCreateInfoEXT* from,
+                                                VkPipelineRobustnessCreateInfoEXT* to);
+
+#endif
 #ifdef VK_EXT_conditional_rendering
 void deepcopy_VkConditionalRenderingBeginInfoEXT(Allocator* alloc, VkStructureType rootType,
                                                  const VkConditionalRenderingBeginInfoEXT* from,
@@ -2414,8 +2727,6 @@ void deepcopy_VkMacOSSurfaceCreateInfoMVK(Allocator* alloc, VkStructureType root
                                           VkMacOSSurfaceCreateInfoMVK* to);
 
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -2491,25 +2802,17 @@ DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSamplerFilterMinmaxProperties,
 #ifdef VK_AMD_shader_fragment_mask
 #endif
 #ifdef VK_EXT_inline_uniform_block
-void deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* from,
-    VkPhysicalDeviceInlineUniformBlockFeaturesEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceInlineUniformBlockFeatures,
+                      deepcopy_VkPhysicalDeviceInlineUniformBlockFeaturesEXT)
 
-void deepcopy_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* from,
-    VkPhysicalDeviceInlineUniformBlockPropertiesEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceInlineUniformBlockProperties,
+                      deepcopy_VkPhysicalDeviceInlineUniformBlockPropertiesEXT)
 
-void deepcopy_VkWriteDescriptorSetInlineUniformBlockEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkWriteDescriptorSetInlineUniformBlockEXT* from,
-    VkWriteDescriptorSetInlineUniformBlockEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkWriteDescriptorSetInlineUniformBlock,
+                      deepcopy_VkWriteDescriptorSetInlineUniformBlockEXT)
 
-void deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* from,
-    VkDescriptorPoolInlineUniformBlockCreateInfoEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfo,
+                      deepcopy_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_shader_stencil_export
@@ -2789,10 +3092,8 @@ void deepcopy_VkFilterCubicImageViewImageFormatPropertiesEXT(
 #ifdef VK_QCOM_render_pass_shader_resolve
 #endif
 #ifdef VK_EXT_global_priority
-void deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkDeviceQueueGlobalPriorityCreateInfoEXT* from,
-    VkDeviceQueueGlobalPriorityCreateInfoEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDeviceQueueGlobalPriorityCreateInfoKHR,
+                      deepcopy_VkDeviceQueueGlobalPriorityCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_external_memory_host
@@ -2830,38 +3131,6 @@ void deepcopy_VkPhysicalDeviceShaderCorePropertiesAMD(
     VkPhysicalDeviceShaderCorePropertiesAMD* to);
 
 #endif
-#ifdef VK_EXT_video_decode_h265
-void deepcopy_VkVideoDecodeH265ProfileEXT(Allocator* alloc, VkStructureType rootType,
-                                          const VkVideoDecodeH265ProfileEXT* from,
-                                          VkVideoDecodeH265ProfileEXT* to);
-
-void deepcopy_VkVideoDecodeH265CapabilitiesEXT(Allocator* alloc, VkStructureType rootType,
-                                               const VkVideoDecodeH265CapabilitiesEXT* from,
-                                               VkVideoDecodeH265CapabilitiesEXT* to);
-
-void deepcopy_VkVideoDecodeH265SessionCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType, const VkVideoDecodeH265SessionCreateInfoEXT* from,
-    VkVideoDecodeH265SessionCreateInfoEXT* to);
-
-void deepcopy_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkVideoDecodeH265SessionParametersAddInfoEXT* from,
-    VkVideoDecodeH265SessionParametersAddInfoEXT* to);
-
-void deepcopy_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkVideoDecodeH265SessionParametersCreateInfoEXT* from,
-    VkVideoDecodeH265SessionParametersCreateInfoEXT* to);
-
-void deepcopy_VkVideoDecodeH265PictureInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                              const VkVideoDecodeH265PictureInfoEXT* from,
-                                              VkVideoDecodeH265PictureInfoEXT* to);
-
-void deepcopy_VkVideoDecodeH265DpbSlotInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                              const VkVideoDecodeH265DpbSlotInfoEXT* from,
-                                              VkVideoDecodeH265DpbSlotInfoEXT* to);
-
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 void deepcopy_VkDeviceMemoryOverallocationCreateInfoAMD(
     Allocator* alloc, VkStructureType rootType,
@@ -2898,13 +3167,10 @@ void deepcopy_VkPresentFrameTokenGGP(Allocator* alloc, VkStructureType rootType,
 
 #endif
 #ifdef VK_EXT_pipeline_creation_feedback
-void deepcopy_VkPipelineCreationFeedbackEXT(Allocator* alloc, VkStructureType rootType,
-                                            const VkPipelineCreationFeedbackEXT* from,
-                                            VkPipelineCreationFeedbackEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineCreationFeedbackCreateInfo,
+                      deepcopy_VkPipelineCreationFeedbackCreateInfoEXT)
 
-void deepcopy_VkPipelineCreationFeedbackCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType, const VkPipelineCreationFeedbackCreateInfoEXT* from,
-    VkPipelineCreationFeedbackCreateInfoEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineCreationFeedback, deepcopy_VkPipelineCreationFeedbackEXT)
 
 #endif
 #ifdef VK_NV_shader_subgroup_partitioned
@@ -2931,10 +3197,8 @@ void deepcopy_VkDrawMeshTasksIndirectCommandNV(Allocator* alloc, VkStructureType
 
 #endif
 #ifdef VK_NV_fragment_shader_barycentric
-void deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* from,
-    VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
+                      deepcopy_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV)
 
 #endif
 #ifdef VK_NV_shader_image_footprint
@@ -3068,20 +3332,14 @@ DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceScalarBlockLayoutFeatures,
 #ifdef VK_GOOGLE_decorate_string
 #endif
 #ifdef VK_EXT_subgroup_size_control
-void deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* from,
-    VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSubgroupSizeControlFeatures,
+                      deepcopy_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)
 
-void deepcopy_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* from,
-    VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceSubgroupSizeControlProperties,
+                      deepcopy_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT)
 
-void deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* from,
-    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)
 
 #endif
 #ifdef VK_AMD_shader_core_properties2
@@ -3147,9 +3405,8 @@ void deepcopy_VkBufferDeviceAddressCreateInfoEXT(Allocator* alloc, VkStructureTy
 
 #endif
 #ifdef VK_EXT_tooling_info
-void deepcopy_VkPhysicalDeviceToolPropertiesEXT(Allocator* alloc, VkStructureType rootType,
-                                                const VkPhysicalDeviceToolPropertiesEXT* from,
-                                                VkPhysicalDeviceToolPropertiesEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceToolProperties,
+                      deepcopy_VkPhysicalDeviceToolPropertiesEXT)
 
 #endif
 #ifdef VK_EXT_separate_stencil_usage
@@ -3298,11 +3555,50 @@ void deepcopy_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
     VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* to);
 
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-void deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+void deepcopy_VkSurfacePresentModeEXT(Allocator* alloc, VkStructureType rootType,
+                                      const VkSurfacePresentModeEXT* from,
+                                      VkSurfacePresentModeEXT* to);
+
+void deepcopy_VkSurfacePresentScalingCapabilitiesEXT(
+    Allocator* alloc, VkStructureType rootType, const VkSurfacePresentScalingCapabilitiesEXT* from,
+    VkSurfacePresentScalingCapabilitiesEXT* to);
+
+void deepcopy_VkSurfacePresentModeCompatibilityEXT(Allocator* alloc, VkStructureType rootType,
+                                                   const VkSurfacePresentModeCompatibilityEXT* from,
+                                                   VkSurfacePresentModeCompatibilityEXT* to);
+
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+void deepcopy_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* from,
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* to);
+    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* from,
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* to);
+
+void deepcopy_VkSwapchainPresentFenceInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                             const VkSwapchainPresentFenceInfoEXT* from,
+                                             VkSwapchainPresentFenceInfoEXT* to);
+
+void deepcopy_VkSwapchainPresentModesCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                   const VkSwapchainPresentModesCreateInfoEXT* from,
+                                                   VkSwapchainPresentModesCreateInfoEXT* to);
+
+void deepcopy_VkSwapchainPresentModeInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkSwapchainPresentModeInfoEXT* from,
+                                            VkSwapchainPresentModeInfoEXT* to);
+
+void deepcopy_VkSwapchainPresentScalingCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType, const VkSwapchainPresentScalingCreateInfoEXT* from,
+    VkSwapchainPresentScalingCreateInfoEXT* to);
+
+void deepcopy_VkReleaseSwapchainImagesInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkReleaseSwapchainImagesInfoEXT* from,
+                                              VkReleaseSwapchainImagesInfoEXT* to);
+
+#endif
+#ifdef VK_EXT_shader_demote_to_helper_invocation
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures,
+                      deepcopy_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)
 
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -3381,10 +3677,8 @@ void deepcopy_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
     const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* from,
     VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* to);
 
-void deepcopy_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* from,
-    VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceTexelBufferAlignmentProperties,
+                      deepcopy_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)
 
 #endif
 #ifdef VK_QCOM_render_pass_transform
@@ -3444,25 +3738,34 @@ void deepcopy_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+void deepcopy_VkPhysicalDevicePresentBarrierFeaturesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePresentBarrierFeaturesNV* from,
+    VkPhysicalDevicePresentBarrierFeaturesNV* to);
+
+void deepcopy_VkSurfaceCapabilitiesPresentBarrierNV(
+    Allocator* alloc, VkStructureType rootType, const VkSurfaceCapabilitiesPresentBarrierNV* from,
+    VkSurfaceCapabilitiesPresentBarrierNV* to);
+
+void deepcopy_VkSwapchainPresentBarrierCreateInfoNV(
+    Allocator* alloc, VkStructureType rootType, const VkSwapchainPresentBarrierCreateInfoNV* from,
+    VkSwapchainPresentBarrierCreateInfoNV* to);
+
+#endif
 #ifdef VK_EXT_private_data
-void deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT(
-    Allocator* alloc, VkStructureType rootType, const VkPhysicalDevicePrivateDataFeaturesEXT* from,
-    VkPhysicalDevicePrivateDataFeaturesEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDevicePrivateDataFeatures,
+                      deepcopy_VkPhysicalDevicePrivateDataFeaturesEXT)
 
-void deepcopy_VkDevicePrivateDataCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                               const VkDevicePrivateDataCreateInfoEXT* from,
-                                               VkDevicePrivateDataCreateInfoEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkDevicePrivateDataCreateInfo,
+                      deepcopy_VkDevicePrivateDataCreateInfoEXT)
 
-void deepcopy_VkPrivateDataSlotCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
-                                             const VkPrivateDataSlotCreateInfoEXT* from,
-                                             VkPrivateDataSlotCreateInfoEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPrivateDataSlotCreateInfo, deepcopy_VkPrivateDataSlotCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
-void deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* from,
-    VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeatures,
+                      deepcopy_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT)
 
 #endif
 #ifdef VK_NV_device_diagnostics_config
@@ -3478,6 +3781,148 @@ void deepcopy_VkDeviceDiagnosticsConfigCreateInfoNV(
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+void deepcopy_VkQueryLowLatencySupportNV(Allocator* alloc, VkStructureType rootType,
+                                         const VkQueryLowLatencySupportNV* from,
+                                         VkQueryLowLatencySupportNV* to);
+
+#endif
+#ifdef VK_EXT_metal_objects
+void deepcopy_VkExportMetalObjectCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                               const VkExportMetalObjectCreateInfoEXT* from,
+                                               VkExportMetalObjectCreateInfoEXT* to);
+
+void deepcopy_VkExportMetalObjectsInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                          const VkExportMetalObjectsInfoEXT* from,
+                                          VkExportMetalObjectsInfoEXT* to);
+
+void deepcopy_VkExportMetalDeviceInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkExportMetalDeviceInfoEXT* from,
+                                         VkExportMetalDeviceInfoEXT* to);
+
+void deepcopy_VkExportMetalCommandQueueInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                               const VkExportMetalCommandQueueInfoEXT* from,
+                                               VkExportMetalCommandQueueInfoEXT* to);
+
+void deepcopy_VkExportMetalBufferInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkExportMetalBufferInfoEXT* from,
+                                         VkExportMetalBufferInfoEXT* to);
+
+void deepcopy_VkImportMetalBufferInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkImportMetalBufferInfoEXT* from,
+                                         VkImportMetalBufferInfoEXT* to);
+
+void deepcopy_VkExportMetalTextureInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                          const VkExportMetalTextureInfoEXT* from,
+                                          VkExportMetalTextureInfoEXT* to);
+
+void deepcopy_VkImportMetalTextureInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                          const VkImportMetalTextureInfoEXT* from,
+                                          VkImportMetalTextureInfoEXT* to);
+
+void deepcopy_VkExportMetalIOSurfaceInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkExportMetalIOSurfaceInfoEXT* from,
+                                            VkExportMetalIOSurfaceInfoEXT* to);
+
+void deepcopy_VkImportMetalIOSurfaceInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkImportMetalIOSurfaceInfoEXT* from,
+                                            VkImportMetalIOSurfaceInfoEXT* to);
+
+void deepcopy_VkExportMetalSharedEventInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkExportMetalSharedEventInfoEXT* from,
+                                              VkExportMetalSharedEventInfoEXT* to);
+
+void deepcopy_VkImportMetalSharedEventInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkImportMetalSharedEventInfoEXT* from,
+                                              VkImportMetalSharedEventInfoEXT* to);
+
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void deepcopy_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorBufferPropertiesEXT* from,
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT* to);
+
+void deepcopy_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* from,
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* to);
+
+void deepcopy_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorBufferFeaturesEXT* from,
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT* to);
+
+void deepcopy_VkDescriptorAddressInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkDescriptorAddressInfoEXT* from,
+                                         VkDescriptorAddressInfoEXT* to);
+
+void deepcopy_VkDescriptorBufferBindingInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                               const VkDescriptorBufferBindingInfoEXT* from,
+                                               VkDescriptorBufferBindingInfoEXT* to);
+
+void deepcopy_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* from,
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* to);
+
+void deepcopy_VkDescriptorDataEXT(Allocator* alloc, VkStructureType rootType,
+                                  const VkDescriptorDataEXT* from, VkDescriptorDataEXT* to);
+
+void deepcopy_VkDescriptorGetInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkDescriptorGetInfoEXT* from,
+                                     VkDescriptorGetInfoEXT* to);
+
+void deepcopy_VkBufferCaptureDescriptorDataInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                   const VkBufferCaptureDescriptorDataInfoEXT* from,
+                                                   VkBufferCaptureDescriptorDataInfoEXT* to);
+
+void deepcopy_VkImageCaptureDescriptorDataInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                  const VkImageCaptureDescriptorDataInfoEXT* from,
+                                                  VkImageCaptureDescriptorDataInfoEXT* to);
+
+void deepcopy_VkImageViewCaptureDescriptorDataInfoEXT(
+    Allocator* alloc, VkStructureType rootType, const VkImageViewCaptureDescriptorDataInfoEXT* from,
+    VkImageViewCaptureDescriptorDataInfoEXT* to);
+
+void deepcopy_VkSamplerCaptureDescriptorDataInfoEXT(
+    Allocator* alloc, VkStructureType rootType, const VkSamplerCaptureDescriptorDataInfoEXT* from,
+    VkSamplerCaptureDescriptorDataInfoEXT* to);
+
+void deepcopy_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkOpaqueCaptureDescriptorDataCreateInfoEXT* from,
+    VkOpaqueCaptureDescriptorDataCreateInfoEXT* to);
+
+void deepcopy_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* from,
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT* to);
+
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+void deepcopy_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* from,
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* to);
+
+void deepcopy_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* from,
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* to);
+
+void deepcopy_VkGraphicsPipelineLibraryCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType, const VkGraphicsPipelineLibraryCreateInfoEXT* from,
+    VkGraphicsPipelineLibraryCreateInfoEXT* to);
+
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+void deepcopy_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* from,
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* to);
+
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void deepcopy_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
     Allocator* alloc, VkStructureType rootType,
@@ -3563,10 +4008,38 @@ void deepcopy_VkCopyCommandTransformInfoQCOM(Allocator* alloc, VkStructureType r
 
 #endif
 #ifdef VK_EXT_image_robustness
-void deepcopy_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceImageRobustnessFeatures,
+                      deepcopy_VkPhysicalDeviceImageRobustnessFeaturesEXT)
+
+#endif
+#ifdef VK_EXT_image_compression_control
+void deepcopy_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceImageRobustnessFeaturesEXT* from,
-    VkPhysicalDeviceImageRobustnessFeaturesEXT* to);
+    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* from,
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT* to);
+
+void deepcopy_VkImageCompressionControlEXT(Allocator* alloc, VkStructureType rootType,
+                                           const VkImageCompressionControlEXT* from,
+                                           VkImageCompressionControlEXT* to);
+
+void deepcopy_VkSubresourceLayout2EXT(Allocator* alloc, VkStructureType rootType,
+                                      const VkSubresourceLayout2EXT* from,
+                                      VkSubresourceLayout2EXT* to);
+
+void deepcopy_VkImageSubresource2EXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkImageSubresource2EXT* from,
+                                     VkImageSubresource2EXT* to);
+
+void deepcopy_VkImageCompressionPropertiesEXT(Allocator* alloc, VkStructureType rootType,
+                                              const VkImageCompressionPropertiesEXT* from,
+                                              VkImageCompressionPropertiesEXT* to);
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+void deepcopy_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* from,
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* to);
 
 #endif
 #ifdef VK_EXT_4444_formats
@@ -3575,6 +4048,42 @@ void deepcopy_VkPhysicalDevice4444FormatsFeaturesEXT(
     VkPhysicalDevice4444FormatsFeaturesEXT* to);
 
 #endif
+#ifdef VK_EXT_device_fault
+void deepcopy_VkPhysicalDeviceFaultFeaturesEXT(Allocator* alloc, VkStructureType rootType,
+                                               const VkPhysicalDeviceFaultFeaturesEXT* from,
+                                               VkPhysicalDeviceFaultFeaturesEXT* to);
+
+void deepcopy_VkDeviceFaultCountsEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkDeviceFaultCountsEXT* from,
+                                     VkDeviceFaultCountsEXT* to);
+
+void deepcopy_VkDeviceFaultAddressInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                          const VkDeviceFaultAddressInfoEXT* from,
+                                          VkDeviceFaultAddressInfoEXT* to);
+
+void deepcopy_VkDeviceFaultVendorInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                         const VkDeviceFaultVendorInfoEXT* from,
+                                         VkDeviceFaultVendorInfoEXT* to);
+
+void deepcopy_VkDeviceFaultInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                   const VkDeviceFaultInfoEXT* from, VkDeviceFaultInfoEXT* to);
+
+void deepcopy_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkDeviceFaultVendorBinaryHeaderVersionOneEXT* from,
+    VkDeviceFaultVendorBinaryHeaderVersionOneEXT* to);
+
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+void deepcopy_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* from,
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* to);
+
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
+                      deepcopy_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM)
+
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 void deepcopy_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
@@ -3591,18 +4100,27 @@ void deepcopy_VkDirectFBSurfaceCreateInfoEXT(Allocator* alloc, VkStructureType r
 
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-void deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+void deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* from,
-    VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* to);
+    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* from,
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* to);
 
-void deepcopy_VkMutableDescriptorTypeListVALVE(Allocator* alloc, VkStructureType rootType,
-                                               const VkMutableDescriptorTypeListVALVE* from,
-                                               VkMutableDescriptorTypeListVALVE* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT,
+                      deepcopy_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)
 
-void deepcopy_VkMutableDescriptorTypeCreateInfoVALVE(
-    Allocator* alloc, VkStructureType rootType, const VkMutableDescriptorTypeCreateInfoVALVE* from,
-    VkMutableDescriptorTypeCreateInfoVALVE* to);
+void deepcopy_VkMutableDescriptorTypeListEXT(Allocator* alloc, VkStructureType rootType,
+                                             const VkMutableDescriptorTypeListEXT* from,
+                                             VkMutableDescriptorTypeListEXT* to);
+
+DEFINE_ALIAS_FUNCTION(deepcopy_VkMutableDescriptorTypeListEXT,
+                      deepcopy_VkMutableDescriptorTypeListVALVE)
+
+void deepcopy_VkMutableDescriptorTypeCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                   const VkMutableDescriptorTypeCreateInfoEXT* from,
+                                                   VkMutableDescriptorTypeCreateInfoEXT* to);
+
+DEFINE_ALIAS_FUNCTION(deepcopy_VkMutableDescriptorTypeCreateInfoEXT,
+                      deepcopy_VkMutableDescriptorTypeCreateInfoVALVE)
 
 #endif
 #ifdef VK_EXT_vertex_input_dynamic_state
@@ -3626,6 +4144,29 @@ void deepcopy_VkPhysicalDeviceDrmPropertiesEXT(Allocator* alloc, VkStructureType
                                                VkPhysicalDeviceDrmPropertiesEXT* to);
 
 #endif
+#ifdef VK_EXT_device_address_binding_report
+void deepcopy_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* from,
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT* to);
+
+void deepcopy_VkDeviceAddressBindingCallbackDataEXT(
+    Allocator* alloc, VkStructureType rootType, const VkDeviceAddressBindingCallbackDataEXT* from,
+    VkDeviceAddressBindingCallbackDataEXT* to);
+
+#endif
+#ifdef VK_EXT_depth_clip_control
+void deepcopy_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClipControlFeaturesEXT* from,
+    VkPhysicalDeviceDepthClipControlFeaturesEXT* to);
+
+void deepcopy_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPipelineViewportDepthClipControlCreateInfoEXT* from,
+    VkPipelineViewportDepthClipControlCreateInfoEXT* to);
+
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 void deepcopy_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
@@ -3738,6 +4279,35 @@ void deepcopy_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
     VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* to);
 
 #endif
+#ifdef VK_EXT_pipeline_properties
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineInfoKHR, deepcopy_VkPipelineInfoEXT)
+
+void deepcopy_VkPipelinePropertiesIdentifierEXT(Allocator* alloc, VkStructureType rootType,
+                                                const VkPipelinePropertiesIdentifierEXT* from,
+                                                VkPipelinePropertiesIdentifierEXT* to);
+
+void deepcopy_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePipelinePropertiesFeaturesEXT* from,
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT* to);
+
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+void deepcopy_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* from,
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* to);
+
+void deepcopy_VkSubpassResolvePerformanceQueryEXT(Allocator* alloc, VkStructureType rootType,
+                                                  const VkSubpassResolvePerformanceQueryEXT* from,
+                                                  VkSubpassResolvePerformanceQueryEXT* to);
+
+void deepcopy_VkMultisampledRenderToSingleSampledInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkMultisampledRenderToSingleSampledInfoEXT* from,
+    VkMultisampledRenderToSingleSampledInfoEXT* to);
+
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void deepcopy_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
@@ -3762,6 +4332,13 @@ void deepcopy_VkPipelineColorWriteCreateInfoEXT(Allocator* alloc, VkStructureTyp
                                                 VkPipelineColorWriteCreateInfoEXT* to);
 
 #endif
+#ifdef VK_EXT_primitives_generated_query
+void deepcopy_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* from,
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* to);
+
+#endif
 #ifdef VK_GOOGLE_gfxstream
 void deepcopy_VkImportColorBufferGOOGLE(Allocator* alloc, VkStructureType rootType,
                                         const VkImportColorBufferGOOGLE* from,
@@ -3775,15 +4352,22 @@ void deepcopy_VkCreateBlobGOOGLE(Allocator* alloc, VkStructureType rootType,
 
 #endif
 #ifdef VK_EXT_global_priority_query
-void deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
-    Allocator* alloc, VkStructureType rootType,
-    const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* from,
-    VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* to);
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR,
+                      deepcopy_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT)
 
-void deepcopy_VkQueueFamilyGlobalPriorityPropertiesEXT(
+DEFINE_ALIAS_FUNCTION(deepcopy_VkQueueFamilyGlobalPriorityPropertiesKHR,
+                      deepcopy_VkQueueFamilyGlobalPriorityPropertiesEXT)
+
+#endif
+#ifdef VK_EXT_image_view_min_lod
+void deepcopy_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
-    const VkQueueFamilyGlobalPriorityPropertiesEXT* from,
-    VkQueueFamilyGlobalPriorityPropertiesEXT* to);
+    const VkPhysicalDeviceImageViewMinLodFeaturesEXT* from,
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT* to);
+
+void deepcopy_VkImageViewMinLodCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                             const VkImageViewMinLodCreateInfoEXT* from,
+                                             VkImageViewMinLodCreateInfoEXT* to);
 
 #endif
 #ifdef VK_EXT_multi_draw
@@ -3803,8 +4387,110 @@ void deepcopy_VkMultiDrawIndexedInfoEXT(Allocator* alloc, VkStructureType rootTy
                                         VkMultiDrawIndexedInfoEXT* to);
 
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+void deepcopy_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* from,
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* to);
+
+#endif
+#ifdef VK_EXT_shader_tile_image
+void deepcopy_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderTileImageFeaturesEXT* from,
+    VkPhysicalDeviceShaderTileImageFeaturesEXT* to);
+
+void deepcopy_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderTileImagePropertiesEXT* from,
+    VkPhysicalDeviceShaderTileImagePropertiesEXT* to);
+
+#endif
+#ifdef VK_EXT_opacity_micromap
+void deepcopy_VkMicromapUsageEXT(Allocator* alloc, VkStructureType rootType,
+                                 const VkMicromapUsageEXT* from, VkMicromapUsageEXT* to);
+
+void deepcopy_VkDeviceOrHostAddressKHR(Allocator* alloc, VkStructureType rootType,
+                                       const VkDeviceOrHostAddressKHR* from,
+                                       VkDeviceOrHostAddressKHR* to);
+
+void deepcopy_VkMicromapBuildInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                     const VkMicromapBuildInfoEXT* from,
+                                     VkMicromapBuildInfoEXT* to);
+
+void deepcopy_VkMicromapCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                      const VkMicromapCreateInfoEXT* from,
+                                      VkMicromapCreateInfoEXT* to);
+
+void deepcopy_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceOpacityMicromapFeaturesEXT* from,
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT* to);
+
+void deepcopy_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceOpacityMicromapPropertiesEXT* from,
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT* to);
+
+void deepcopy_VkMicromapVersionInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                       const VkMicromapVersionInfoEXT* from,
+                                       VkMicromapVersionInfoEXT* to);
+
+void deepcopy_VkCopyMicromapToMemoryInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkCopyMicromapToMemoryInfoEXT* from,
+                                            VkCopyMicromapToMemoryInfoEXT* to);
+
+void deepcopy_VkCopyMemoryToMicromapInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                            const VkCopyMemoryToMicromapInfoEXT* from,
+                                            VkCopyMemoryToMicromapInfoEXT* to);
+
+void deepcopy_VkCopyMicromapInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                    const VkCopyMicromapInfoEXT* from, VkCopyMicromapInfoEXT* to);
+
+void deepcopy_VkMicromapBuildSizesInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                          const VkMicromapBuildSizesInfoEXT* from,
+                                          VkMicromapBuildSizesInfoEXT* to);
+
+void deepcopy_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkAccelerationStructureTrianglesOpacityMicromapEXT* from,
+    VkAccelerationStructureTrianglesOpacityMicromapEXT* to);
+
+void deepcopy_VkMicromapTriangleEXT(Allocator* alloc, VkStructureType rootType,
+                                    const VkMicromapTriangleEXT* from, VkMicromapTriangleEXT* to);
+
+#endif
+#ifdef VK_NV_displacement_micromap
+void deepcopy_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* from,
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV* to);
+
+void deepcopy_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* from,
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV* to);
+
+void deepcopy_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkAccelerationStructureTrianglesDisplacementMicromapNV* from,
+    VkAccelerationStructureTrianglesDisplacementMicromapNV* to);
+
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void deepcopy_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* from,
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* to);
+
+void deepcopy_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* from,
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* to);
+
+#endif
 #ifdef VK_EXT_border_color_swizzle
 void deepcopy_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
     Allocator* alloc, VkStructureType rootType,
@@ -3824,11 +4510,363 @@ void deepcopy_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
     VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* to);
 
 #endif
-#ifdef VK_KHR_acceleration_structure
-void deepcopy_VkDeviceOrHostAddressKHR(Allocator* alloc, VkStructureType rootType,
-                                       const VkDeviceOrHostAddressKHR* from,
-                                       VkDeviceOrHostAddressKHR* to);
+#ifdef VK_ARM_shader_core_properties
+void deepcopy_VkPhysicalDeviceShaderCorePropertiesARM(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceShaderCorePropertiesARM* from,
+    VkPhysicalDeviceShaderCorePropertiesARM* to);
+
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+void deepcopy_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* from,
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* to);
+
+void deepcopy_VkImageViewSlicedCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                             const VkImageViewSlicedCreateInfoEXT* from,
+                                             VkImageViewSlicedCreateInfoEXT* to);
+
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void deepcopy_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* from,
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* to);
+
+void deepcopy_VkDescriptorSetBindingReferenceVALVE(Allocator* alloc, VkStructureType rootType,
+                                                   const VkDescriptorSetBindingReferenceVALVE* from,
+                                                   VkDescriptorSetBindingReferenceVALVE* to);
+
+void deepcopy_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    Allocator* alloc, VkStructureType rootType,
+    const VkDescriptorSetLayoutHostMappingInfoVALVE* from,
+    VkDescriptorSetLayoutHostMappingInfoVALVE* to);
 
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+void deepcopy_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* from,
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* to);
+
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+void deepcopy_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* from,
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* to);
+
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+void deepcopy_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* from,
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* to);
+
+void deepcopy_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* from,
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* to);
+
+void deepcopy_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* from,
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* to);
+
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void deepcopy_VkCopyMemoryIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+                                            const VkCopyMemoryIndirectCommandNV* from,
+                                            VkCopyMemoryIndirectCommandNV* to);
+
+void deepcopy_VkCopyMemoryToImageIndirectCommandNV(Allocator* alloc, VkStructureType rootType,
+                                                   const VkCopyMemoryToImageIndirectCommandNV* from,
+                                                   VkCopyMemoryToImageIndirectCommandNV* to);
+
+void deepcopy_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* from,
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* to);
+
+void deepcopy_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* from,
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* to);
+
+#endif
+#ifdef VK_NV_memory_decompression
+void deepcopy_VkDecompressMemoryRegionNV(Allocator* alloc, VkStructureType rootType,
+                                         const VkDecompressMemoryRegionNV* from,
+                                         VkDecompressMemoryRegionNV* to);
+
+void deepcopy_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceMemoryDecompressionFeaturesNV* from,
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV* to);
+
+void deepcopy_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* from,
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV* to);
+
+#endif
+#ifdef VK_NV_linear_color_attachment
+void deepcopy_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* from,
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* to);
+
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+void deepcopy_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* from,
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* to);
+
+#endif
+#ifdef VK_QCOM_image_processing
+void deepcopy_VkImageViewSampleWeightCreateInfoQCOM(
+    Allocator* alloc, VkStructureType rootType, const VkImageViewSampleWeightCreateInfoQCOM* from,
+    VkImageViewSampleWeightCreateInfoQCOM* to);
+
+void deepcopy_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceImageProcessingFeaturesQCOM* from,
+    VkPhysicalDeviceImageProcessingFeaturesQCOM* to);
+
+void deepcopy_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceImageProcessingPropertiesQCOM* from,
+    VkPhysicalDeviceImageProcessingPropertiesQCOM* to);
+
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void deepcopy_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* from,
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* to);
+
+void deepcopy_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* from,
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* to);
+
+void deepcopy_VkColorBlendEquationEXT(Allocator* alloc, VkStructureType rootType,
+                                      const VkColorBlendEquationEXT* from,
+                                      VkColorBlendEquationEXT* to);
+
+void deepcopy_VkColorBlendAdvancedEXT(Allocator* alloc, VkStructureType rootType,
+                                      const VkColorBlendAdvancedEXT* from,
+                                      VkColorBlendAdvancedEXT* to);
+
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+void deepcopy_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* from,
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* to);
+
+void deepcopy_VkRenderPassCreationControlEXT(Allocator* alloc, VkStructureType rootType,
+                                             const VkRenderPassCreationControlEXT* from,
+                                             VkRenderPassCreationControlEXT* to);
+
+void deepcopy_VkRenderPassCreationFeedbackInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                  const VkRenderPassCreationFeedbackInfoEXT* from,
+                                                  VkRenderPassCreationFeedbackInfoEXT* to);
+
+void deepcopy_VkRenderPassCreationFeedbackCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkRenderPassCreationFeedbackCreateInfoEXT* from,
+    VkRenderPassCreationFeedbackCreateInfoEXT* to);
+
+void deepcopy_VkRenderPassSubpassFeedbackInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                                 const VkRenderPassSubpassFeedbackInfoEXT* from,
+                                                 VkRenderPassSubpassFeedbackInfoEXT* to);
+
+void deepcopy_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkRenderPassSubpassFeedbackCreateInfoEXT* from,
+    VkRenderPassSubpassFeedbackCreateInfoEXT* to);
+
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+void deepcopy_VkDirectDriverLoadingInfoLUNARG(Allocator* alloc, VkStructureType rootType,
+                                              const VkDirectDriverLoadingInfoLUNARG* from,
+                                              VkDirectDriverLoadingInfoLUNARG* to);
+
+void deepcopy_VkDirectDriverLoadingListLUNARG(Allocator* alloc, VkStructureType rootType,
+                                              const VkDirectDriverLoadingListLUNARG* from,
+                                              VkDirectDriverLoadingListLUNARG* to);
+
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void deepcopy_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* from,
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* to);
+
+void deepcopy_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* from,
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* to);
+
+void deepcopy_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* from,
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* to);
+
+void deepcopy_VkShaderModuleIdentifierEXT(Allocator* alloc, VkStructureType rootType,
+                                          const VkShaderModuleIdentifierEXT* from,
+                                          VkShaderModuleIdentifierEXT* to);
+
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+void deepcopy_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceOpticalFlowFeaturesNV* from,
+    VkPhysicalDeviceOpticalFlowFeaturesNV* to);
+
+void deepcopy_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceOpticalFlowPropertiesNV* from,
+    VkPhysicalDeviceOpticalFlowPropertiesNV* to);
+
+void deepcopy_VkOpticalFlowImageFormatInfoNV(Allocator* alloc, VkStructureType rootType,
+                                             const VkOpticalFlowImageFormatInfoNV* from,
+                                             VkOpticalFlowImageFormatInfoNV* to);
+
+void deepcopy_VkOpticalFlowImageFormatPropertiesNV(Allocator* alloc, VkStructureType rootType,
+                                                   const VkOpticalFlowImageFormatPropertiesNV* from,
+                                                   VkOpticalFlowImageFormatPropertiesNV* to);
+
+void deepcopy_VkOpticalFlowSessionCreateInfoNV(Allocator* alloc, VkStructureType rootType,
+                                               const VkOpticalFlowSessionCreateInfoNV* from,
+                                               VkOpticalFlowSessionCreateInfoNV* to);
+
+void deepcopy_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkOpticalFlowSessionCreatePrivateDataInfoNV* from,
+    VkOpticalFlowSessionCreatePrivateDataInfoNV* to);
+
+void deepcopy_VkOpticalFlowExecuteInfoNV(Allocator* alloc, VkStructureType rootType,
+                                         const VkOpticalFlowExecuteInfoNV* from,
+                                         VkOpticalFlowExecuteInfoNV* to);
+
+#endif
+#ifdef VK_EXT_legacy_dithering
+void deepcopy_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceLegacyDitheringFeaturesEXT* from,
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT* to);
+
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+void deepcopy_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* from,
+    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* to);
+
+#endif
+#ifdef VK_EXT_shader_object
+void deepcopy_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceShaderObjectFeaturesEXT* from,
+    VkPhysicalDeviceShaderObjectFeaturesEXT* to);
+
+void deepcopy_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderObjectPropertiesEXT* from,
+    VkPhysicalDeviceShaderObjectPropertiesEXT* to);
+
+void deepcopy_VkShaderCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+                                    const VkShaderCreateInfoEXT* from, VkShaderCreateInfoEXT* to);
+
+DEFINE_ALIAS_FUNCTION(deepcopy_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      deepcopy_VkShaderRequiredSubgroupSizeCreateInfoEXT)
+
+#endif
+#ifdef VK_QCOM_tile_properties
+void deepcopy_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceTilePropertiesFeaturesQCOM* from,
+    VkPhysicalDeviceTilePropertiesFeaturesQCOM* to);
+
+void deepcopy_VkTilePropertiesQCOM(Allocator* alloc, VkStructureType rootType,
+                                   const VkTilePropertiesQCOM* from, VkTilePropertiesQCOM* to);
+
+#endif
+#ifdef VK_SEC_amigo_profiling
+void deepcopy_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceAmigoProfilingFeaturesSEC* from,
+    VkPhysicalDeviceAmigoProfilingFeaturesSEC* to);
+
+void deepcopy_VkAmigoProfilingSubmitInfoSEC(Allocator* alloc, VkStructureType rootType,
+                                            const VkAmigoProfilingSubmitInfoSEC* from,
+                                            VkAmigoProfilingSubmitInfoSEC* to);
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+void deepcopy_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* from,
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* to);
+
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+void deepcopy_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* from,
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* to);
+
+void deepcopy_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* from,
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* to);
+
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+void deepcopy_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* from,
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* to);
+
+void deepcopy_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* from,
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* to);
+
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+void deepcopy_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* from,
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* to);
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+void deepcopy_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* from,
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* to);
+
+void deepcopy_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    Allocator* alloc, VkStructureType rootType,
+    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* from,
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* to);
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+void deepcopy_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType,
+    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* from,
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* to);
+
+#endif
+#ifdef VK_KHR_acceleration_structure
 void deepcopy_VkAccelerationStructureBuildRangeInfoKHR(
     Allocator* alloc, VkStructureType rootType,
     const VkAccelerationStructureBuildRangeInfoKHR* from,
@@ -3949,6 +4987,20 @@ void deepcopy_VkPhysicalDeviceRayQueryFeaturesKHR(Allocator* alloc, VkStructureT
                                                   VkPhysicalDeviceRayQueryFeaturesKHR* to);
 
 #endif
+#ifdef VK_EXT_mesh_shader
+void deepcopy_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMeshShaderFeaturesEXT* from,
+    VkPhysicalDeviceMeshShaderFeaturesEXT* to);
+
+void deepcopy_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    Allocator* alloc, VkStructureType rootType, const VkPhysicalDeviceMeshShaderPropertiesEXT* from,
+    VkPhysicalDeviceMeshShaderPropertiesEXT* to);
+
+void deepcopy_VkDrawMeshTasksIndirectCommandEXT(Allocator* alloc, VkStructureType rootType,
+                                                const VkDrawMeshTasksIndirectCommandEXT* from,
+                                                VkDrawMeshTasksIndirectCommandEXT* to);
+
+#endif
 
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_dispatch.cpp b/stream-servers/vulkan/cereal/common/goldfish_vk_dispatch.cpp
index 73244a94..67dcb798 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_dispatch.cpp
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_dispatch.cpp
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_dispatch
 //
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (impl) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -44,6 +44,8 @@ namespace vk {
 #endif
 #ifdef VK_VERSION_1_2
 #endif
+#ifdef VK_VERSION_1_3
+#endif
 #ifdef VK_KHR_surface
 #endif
 #ifdef VK_KHR_swapchain
@@ -68,6 +70,8 @@ namespace vk {
 #endif
 #ifdef VK_KHR_video_decode_queue
 #endif
+#ifdef VK_KHR_video_decode_h264
+#endif
 #ifdef VK_KHR_dynamic_rendering
 #endif
 #ifdef VK_KHR_multiview
@@ -162,6 +166,10 @@ namespace vk {
 #endif
 #ifdef VK_KHR_shader_clock
 #endif
+#ifdef VK_KHR_video_decode_h265
+#endif
+#ifdef VK_KHR_global_priority
+#endif
 #ifdef VK_KHR_driver_properties
 #endif
 #ifdef VK_KHR_shader_float_controls
@@ -194,6 +202,8 @@ namespace vk {
 #endif
 #ifdef VK_KHR_pipeline_executable_properties
 #endif
+#ifdef VK_KHR_map_memory2
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -206,6 +216,8 @@ namespace vk {
 #endif
 #ifdef VK_KHR_synchronization2
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
@@ -216,8 +228,14 @@ namespace vk {
 #endif
 #ifdef VK_KHR_format_feature_flags2
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
 #ifdef VK_EXT_debug_report
@@ -258,8 +276,6 @@ namespace vk {
 #endif
 #ifdef VK_EXT_video_encode_h265
 #endif
-#ifdef VK_EXT_video_decode_h264
-#endif
 #ifdef VK_AMD_texture_gather_bias_lod
 #endif
 #ifdef VK_AMD_shader_info
@@ -292,6 +308,8 @@ namespace vk {
 #endif
 #ifdef VK_EXT_astc_decode_mode
 #endif
+#ifdef VK_EXT_pipeline_robustness
+#endif
 #ifdef VK_EXT_conditional_rendering
 #endif
 #ifdef VK_NV_clip_space_w_scaling
@@ -330,8 +348,6 @@ namespace vk {
 #endif
 #ifdef VK_MVK_macos_surface
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -396,8 +412,6 @@ namespace vk {
 #endif
 #ifdef VK_AMD_shader_core_properties
 #endif
-#ifdef VK_EXT_video_decode_h265
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 #endif
 #ifdef VK_EXT_vertex_attribute_divisor
@@ -488,6 +502,10 @@ namespace vk {
 #endif
 #ifdef VK_EXT_shader_atomic_float2
 #endif
+#ifdef VK_EXT_surface_maintenance1
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+#endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -508,6 +526,8 @@ namespace vk {
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+#endif
 #ifdef VK_EXT_private_data
 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
@@ -516,6 +536,16 @@ namespace vk {
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+#endif
+#ifdef VK_EXT_metal_objects
+#endif
+#ifdef VK_EXT_descriptor_buffer
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
 #endif
 #ifdef VK_NV_ray_tracing_motion_blur
@@ -528,8 +558,16 @@ namespace vk {
 #endif
 #ifdef VK_EXT_image_robustness
 #endif
+#ifdef VK_EXT_image_compression_control
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+#endif
 #ifdef VK_EXT_4444_formats
 #endif
+#ifdef VK_EXT_device_fault
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 #endif
 #ifdef VK_NV_acquire_winrt_display
@@ -542,6 +580,10 @@ namespace vk {
 #endif
 #ifdef VK_EXT_physical_device_drm
 #endif
+#ifdef VK_EXT_device_address_binding_report
+#endif
+#ifdef VK_EXT_depth_clip_control
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 #endif
 #ifdef VK_FUCHSIA_external_memory
@@ -556,30 +598,110 @@ namespace vk {
 #endif
 #ifdef VK_NV_external_memory_rdma
 #endif
+#ifdef VK_EXT_pipeline_properties
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 #endif
 #ifdef VK_QNX_screen_surface
 #endif
 #ifdef VK_EXT_color_write_enable
 #endif
+#ifdef VK_EXT_primitives_generated_query
+#endif
 #ifdef VK_GOOGLE_gfxstream
 #endif
 #ifdef VK_EXT_global_priority_query
 #endif
+#ifdef VK_EXT_image_view_min_lod
+#endif
 #ifdef VK_EXT_multi_draw
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+#endif
+#ifdef VK_EXT_shader_tile_image
+#endif
+#ifdef VK_EXT_opacity_micromap
+#endif
+#ifdef VK_NV_displacement_micromap
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+#endif
 #ifdef VK_EXT_border_color_swizzle
 #endif
 #ifdef VK_EXT_pageable_device_local_memory
 #endif
+#ifdef VK_ARM_shader_core_properties
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+#endif
+#ifdef VK_NV_copy_memory_indirect
+#endif
+#ifdef VK_NV_memory_decompression
+#endif
+#ifdef VK_NV_linear_color_attachment
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+#endif
+#ifdef VK_QCOM_image_processing
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+#endif
+#ifdef VK_EXT_shader_module_identifier
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+#endif
+#ifdef VK_EXT_legacy_dithering
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+#endif
+#ifdef VK_EXT_shader_object
+#endif
+#ifdef VK_QCOM_tile_properties
+#endif
+#ifdef VK_SEC_amigo_profiling
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+#endif
 #ifdef VK_KHR_acceleration_structure
 #endif
 #ifdef VK_KHR_ray_tracing_pipeline
 #endif
 #ifdef VK_KHR_ray_query
 #endif
+#ifdef VK_EXT_mesh_shader
+#endif
 
 void init_vulkan_dispatch_from_system_loader(DlOpenFunc dlOpenFunc, DlSymFunc dlSymFunc,
                                              VulkanDispatch* out) {
@@ -954,6 +1076,66 @@ void init_vulkan_dispatch_from_system_loader(DlOpenFunc dlOpenFunc, DlSymFunc dl
         (PFN_vkGetDeviceMemoryOpaqueCaptureAddress)dlSymFunc(
             lib, "vkGetDeviceMemoryOpaqueCaptureAddress");
 #endif
+#ifdef VK_VERSION_1_3
+    out->vkGetPhysicalDeviceToolProperties =
+        (PFN_vkGetPhysicalDeviceToolProperties)dlSymFunc(lib, "vkGetPhysicalDeviceToolProperties");
+    out->vkCreatePrivateDataSlot =
+        (PFN_vkCreatePrivateDataSlot)dlSymFunc(lib, "vkCreatePrivateDataSlot");
+    out->vkDestroyPrivateDataSlot =
+        (PFN_vkDestroyPrivateDataSlot)dlSymFunc(lib, "vkDestroyPrivateDataSlot");
+    out->vkSetPrivateData = (PFN_vkSetPrivateData)dlSymFunc(lib, "vkSetPrivateData");
+    out->vkGetPrivateData = (PFN_vkGetPrivateData)dlSymFunc(lib, "vkGetPrivateData");
+    out->vkCmdSetEvent2 = (PFN_vkCmdSetEvent2)dlSymFunc(lib, "vkCmdSetEvent2");
+    out->vkCmdResetEvent2 = (PFN_vkCmdResetEvent2)dlSymFunc(lib, "vkCmdResetEvent2");
+    out->vkCmdWaitEvents2 = (PFN_vkCmdWaitEvents2)dlSymFunc(lib, "vkCmdWaitEvents2");
+    out->vkCmdPipelineBarrier2 = (PFN_vkCmdPipelineBarrier2)dlSymFunc(lib, "vkCmdPipelineBarrier2");
+    out->vkCmdWriteTimestamp2 = (PFN_vkCmdWriteTimestamp2)dlSymFunc(lib, "vkCmdWriteTimestamp2");
+    out->vkQueueSubmit2 = (PFN_vkQueueSubmit2)dlSymFunc(lib, "vkQueueSubmit2");
+    out->vkCmdCopyBuffer2 = (PFN_vkCmdCopyBuffer2)dlSymFunc(lib, "vkCmdCopyBuffer2");
+    out->vkCmdCopyImage2 = (PFN_vkCmdCopyImage2)dlSymFunc(lib, "vkCmdCopyImage2");
+    out->vkCmdCopyBufferToImage2 =
+        (PFN_vkCmdCopyBufferToImage2)dlSymFunc(lib, "vkCmdCopyBufferToImage2");
+    out->vkCmdCopyImageToBuffer2 =
+        (PFN_vkCmdCopyImageToBuffer2)dlSymFunc(lib, "vkCmdCopyImageToBuffer2");
+    out->vkCmdBlitImage2 = (PFN_vkCmdBlitImage2)dlSymFunc(lib, "vkCmdBlitImage2");
+    out->vkCmdResolveImage2 = (PFN_vkCmdResolveImage2)dlSymFunc(lib, "vkCmdResolveImage2");
+    out->vkCmdBeginRendering = (PFN_vkCmdBeginRendering)dlSymFunc(lib, "vkCmdBeginRendering");
+    out->vkCmdEndRendering = (PFN_vkCmdEndRendering)dlSymFunc(lib, "vkCmdEndRendering");
+    out->vkCmdSetCullMode = (PFN_vkCmdSetCullMode)dlSymFunc(lib, "vkCmdSetCullMode");
+    out->vkCmdSetFrontFace = (PFN_vkCmdSetFrontFace)dlSymFunc(lib, "vkCmdSetFrontFace");
+    out->vkCmdSetPrimitiveTopology =
+        (PFN_vkCmdSetPrimitiveTopology)dlSymFunc(lib, "vkCmdSetPrimitiveTopology");
+    out->vkCmdSetViewportWithCount =
+        (PFN_vkCmdSetViewportWithCount)dlSymFunc(lib, "vkCmdSetViewportWithCount");
+    out->vkCmdSetScissorWithCount =
+        (PFN_vkCmdSetScissorWithCount)dlSymFunc(lib, "vkCmdSetScissorWithCount");
+    out->vkCmdBindVertexBuffers2 =
+        (PFN_vkCmdBindVertexBuffers2)dlSymFunc(lib, "vkCmdBindVertexBuffers2");
+    out->vkCmdSetDepthTestEnable =
+        (PFN_vkCmdSetDepthTestEnable)dlSymFunc(lib, "vkCmdSetDepthTestEnable");
+    out->vkCmdSetDepthWriteEnable =
+        (PFN_vkCmdSetDepthWriteEnable)dlSymFunc(lib, "vkCmdSetDepthWriteEnable");
+    out->vkCmdSetDepthCompareOp =
+        (PFN_vkCmdSetDepthCompareOp)dlSymFunc(lib, "vkCmdSetDepthCompareOp");
+    out->vkCmdSetDepthBoundsTestEnable =
+        (PFN_vkCmdSetDepthBoundsTestEnable)dlSymFunc(lib, "vkCmdSetDepthBoundsTestEnable");
+    out->vkCmdSetStencilTestEnable =
+        (PFN_vkCmdSetStencilTestEnable)dlSymFunc(lib, "vkCmdSetStencilTestEnable");
+    out->vkCmdSetStencilOp = (PFN_vkCmdSetStencilOp)dlSymFunc(lib, "vkCmdSetStencilOp");
+    out->vkCmdSetRasterizerDiscardEnable =
+        (PFN_vkCmdSetRasterizerDiscardEnable)dlSymFunc(lib, "vkCmdSetRasterizerDiscardEnable");
+    out->vkCmdSetDepthBiasEnable =
+        (PFN_vkCmdSetDepthBiasEnable)dlSymFunc(lib, "vkCmdSetDepthBiasEnable");
+    out->vkCmdSetPrimitiveRestartEnable =
+        (PFN_vkCmdSetPrimitiveRestartEnable)dlSymFunc(lib, "vkCmdSetPrimitiveRestartEnable");
+    out->vkGetDeviceBufferMemoryRequirements = (PFN_vkGetDeviceBufferMemoryRequirements)dlSymFunc(
+        lib, "vkGetDeviceBufferMemoryRequirements");
+    out->vkGetDeviceImageMemoryRequirements = (PFN_vkGetDeviceImageMemoryRequirements)dlSymFunc(
+        lib, "vkGetDeviceImageMemoryRequirements");
+    out->vkGetDeviceImageSparseMemoryRequirements =
+        (PFN_vkGetDeviceImageSparseMemoryRequirements)dlSymFunc(
+            lib, "vkGetDeviceImageSparseMemoryRequirements");
+#endif
 #ifdef VK_KHR_surface
     out->vkGetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR)dlSymFunc(
         lib, "vkGetPhysicalDeviceSurfaceSupportKHR");
@@ -1257,6 +1439,10 @@ void init_vulkan_dispatch_from_system_loader(DlOpenFunc dlOpenFunc, DlSymFunc dl
         (PFN_vkGetPipelineExecutableInternalRepresentationsKHR)dlSymFunc(
             lib, "vkGetPipelineExecutableInternalRepresentationsKHR");
 #endif
+#ifdef VK_KHR_map_memory2
+    out->vkMapMemory2KHR = (PFN_vkMapMemory2KHR)dlSymFunc(lib, "vkMapMemory2KHR");
+    out->vkUnmapMemory2KHR = (PFN_vkUnmapMemory2KHR)dlSymFunc(lib, "vkUnmapMemory2KHR");
+#endif
 #ifdef VK_KHR_video_encode_queue
     out->vkCmdEncodeVideoKHR = (PFN_vkCmdEncodeVideoKHR)dlSymFunc(lib, "vkCmdEncodeVideoKHR");
 #endif
@@ -1284,6 +1470,10 @@ void init_vulkan_dispatch_from_system_loader(DlOpenFunc dlOpenFunc, DlSymFunc dl
     out->vkCmdBlitImage2KHR = (PFN_vkCmdBlitImage2KHR)dlSymFunc(lib, "vkCmdBlitImage2KHR");
     out->vkCmdResolveImage2KHR = (PFN_vkCmdResolveImage2KHR)dlSymFunc(lib, "vkCmdResolveImage2KHR");
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+    out->vkCmdTraceRaysIndirect2KHR =
+        (PFN_vkCmdTraceRaysIndirect2KHR)dlSymFunc(lib, "vkCmdTraceRaysIndirect2KHR");
+#endif
 #ifdef VK_KHR_maintenance4
     out->vkGetDeviceBufferMemoryRequirementsKHR =
         (PFN_vkGetDeviceBufferMemoryRequirementsKHR)dlSymFunc(
@@ -1301,6 +1491,8 @@ void init_vulkan_dispatch_from_system_loader(DlOpenFunc dlOpenFunc, DlSymFunc dl
     out->vkAcquireImageANDROID = (PFN_vkAcquireImageANDROID)dlSymFunc(lib, "vkAcquireImageANDROID");
     out->vkQueueSignalReleaseImageANDROID =
         (PFN_vkQueueSignalReleaseImageANDROID)dlSymFunc(lib, "vkQueueSignalReleaseImageANDROID");
+    out->vkGetSwapchainGrallocUsage2ANDROID = (PFN_vkGetSwapchainGrallocUsage2ANDROID)dlSymFunc(
+        lib, "vkGetSwapchainGrallocUsage2ANDROID");
 #endif
 #ifdef VK_EXT_debug_marker
     out->vkDebugMarkerSetObjectTagEXT =
@@ -1404,6 +1596,10 @@ void init_vulkan_dispatch_from_system_loader(DlOpenFunc dlOpenFunc, DlSymFunc dl
 #ifdef VK_EXT_discard_rectangles
     out->vkCmdSetDiscardRectangleEXT =
         (PFN_vkCmdSetDiscardRectangleEXT)dlSymFunc(lib, "vkCmdSetDiscardRectangleEXT");
+    out->vkCmdSetDiscardRectangleEnableEXT =
+        (PFN_vkCmdSetDiscardRectangleEnableEXT)dlSymFunc(lib, "vkCmdSetDiscardRectangleEnableEXT");
+    out->vkCmdSetDiscardRectangleModeEXT =
+        (PFN_vkCmdSetDiscardRectangleModeEXT)dlSymFunc(lib, "vkCmdSetDiscardRectangleModeEXT");
 #endif
 #ifdef VK_EXT_hdr_metadata
     out->vkSetHdrMetadataEXT = (PFN_vkSetHdrMetadataEXT)dlSymFunc(lib, "vkSetHdrMetadataEXT");
@@ -1515,6 +1711,8 @@ void init_vulkan_dispatch_from_system_loader(DlOpenFunc dlOpenFunc, DlSymFunc dl
         (PFN_vkCmdDrawMeshTasksIndirectCountNV)dlSymFunc(lib, "vkCmdDrawMeshTasksIndirectCountNV");
 #endif
 #ifdef VK_NV_scissor_exclusive
+    out->vkCmdSetExclusiveScissorEnableNV =
+        (PFN_vkCmdSetExclusiveScissorEnableNV)dlSymFunc(lib, "vkCmdSetExclusiveScissorEnableNV");
     out->vkCmdSetExclusiveScissorNV =
         (PFN_vkCmdSetExclusiveScissorNV)dlSymFunc(lib, "vkCmdSetExclusiveScissorNV");
 #endif
@@ -1609,6 +1807,10 @@ void init_vulkan_dispatch_from_system_loader(DlOpenFunc dlOpenFunc, DlSymFunc dl
         (PFN_vkCmdSetStencilTestEnableEXT)dlSymFunc(lib, "vkCmdSetStencilTestEnableEXT");
     out->vkCmdSetStencilOpEXT = (PFN_vkCmdSetStencilOpEXT)dlSymFunc(lib, "vkCmdSetStencilOpEXT");
 #endif
+#ifdef VK_EXT_swapchain_maintenance1
+    out->vkReleaseSwapchainImagesEXT =
+        (PFN_vkReleaseSwapchainImagesEXT)dlSymFunc(lib, "vkReleaseSwapchainImagesEXT");
+#endif
 #ifdef VK_NV_device_generated_commands
     out->vkGetGeneratedCommandsMemoryRequirementsNV =
         (PFN_vkGetGeneratedCommandsMemoryRequirementsNV)dlSymFunc(
@@ -1637,10 +1839,52 @@ void init_vulkan_dispatch_from_system_loader(DlOpenFunc dlOpenFunc, DlSymFunc dl
     out->vkSetPrivateDataEXT = (PFN_vkSetPrivateDataEXT)dlSymFunc(lib, "vkSetPrivateDataEXT");
     out->vkGetPrivateDataEXT = (PFN_vkGetPrivateDataEXT)dlSymFunc(lib, "vkGetPrivateDataEXT");
 #endif
+#ifdef VK_EXT_metal_objects
+    out->vkExportMetalObjectsEXT =
+        (PFN_vkExportMetalObjectsEXT)dlSymFunc(lib, "vkExportMetalObjectsEXT");
+#endif
+#ifdef VK_EXT_descriptor_buffer
+    out->vkGetDescriptorSetLayoutSizeEXT =
+        (PFN_vkGetDescriptorSetLayoutSizeEXT)dlSymFunc(lib, "vkGetDescriptorSetLayoutSizeEXT");
+    out->vkGetDescriptorSetLayoutBindingOffsetEXT =
+        (PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)dlSymFunc(
+            lib, "vkGetDescriptorSetLayoutBindingOffsetEXT");
+    out->vkGetDescriptorEXT = (PFN_vkGetDescriptorEXT)dlSymFunc(lib, "vkGetDescriptorEXT");
+    out->vkCmdBindDescriptorBuffersEXT =
+        (PFN_vkCmdBindDescriptorBuffersEXT)dlSymFunc(lib, "vkCmdBindDescriptorBuffersEXT");
+    out->vkCmdSetDescriptorBufferOffsetsEXT = (PFN_vkCmdSetDescriptorBufferOffsetsEXT)dlSymFunc(
+        lib, "vkCmdSetDescriptorBufferOffsetsEXT");
+    out->vkCmdBindDescriptorBufferEmbeddedSamplersEXT =
+        (PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)dlSymFunc(
+            lib, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT");
+    out->vkGetBufferOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)dlSymFunc(
+            lib, "vkGetBufferOpaqueCaptureDescriptorDataEXT");
+    out->vkGetImageOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)dlSymFunc(
+            lib, "vkGetImageOpaqueCaptureDescriptorDataEXT");
+    out->vkGetImageViewOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)dlSymFunc(
+            lib, "vkGetImageViewOpaqueCaptureDescriptorDataEXT");
+    out->vkGetSamplerOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)dlSymFunc(
+            lib, "vkGetSamplerOpaqueCaptureDescriptorDataEXT");
+    out->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)dlSymFunc(
+            lib, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT");
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
     out->vkCmdSetFragmentShadingRateEnumNV =
         (PFN_vkCmdSetFragmentShadingRateEnumNV)dlSymFunc(lib, "vkCmdSetFragmentShadingRateEnumNV");
 #endif
+#ifdef VK_EXT_image_compression_control
+    out->vkGetImageSubresourceLayout2EXT =
+        (PFN_vkGetImageSubresourceLayout2EXT)dlSymFunc(lib, "vkGetImageSubresourceLayout2EXT");
+#endif
+#ifdef VK_EXT_device_fault
+    out->vkGetDeviceFaultInfoEXT =
+        (PFN_vkGetDeviceFaultInfoEXT)dlSymFunc(lib, "vkGetDeviceFaultInfoEXT");
+#endif
 #ifdef VK_NV_acquire_winrt_display
     out->vkAcquireWinrtDisplayNV =
         (PFN_vkAcquireWinrtDisplayNV)dlSymFunc(lib, "vkAcquireWinrtDisplayNV");
@@ -1698,6 +1942,10 @@ void init_vulkan_dispatch_from_system_loader(DlOpenFunc dlOpenFunc, DlSymFunc dl
     out->vkGetMemoryRemoteAddressNV =
         (PFN_vkGetMemoryRemoteAddressNV)dlSymFunc(lib, "vkGetMemoryRemoteAddressNV");
 #endif
+#ifdef VK_EXT_pipeline_properties
+    out->vkGetPipelinePropertiesEXT =
+        (PFN_vkGetPipelinePropertiesEXT)dlSymFunc(lib, "vkGetPipelinePropertiesEXT");
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
     out->vkCmdSetPatchControlPointsEXT =
         (PFN_vkCmdSetPatchControlPointsEXT)dlSymFunc(lib, "vkCmdSetPatchControlPointsEXT");
@@ -1765,16 +2013,175 @@ void init_vulkan_dispatch_from_system_loader(DlOpenFunc dlOpenFunc, DlSymFunc dl
         (PFN_vkQueueFlushCommandsFromAuxMemoryGOOGLE)dlSymFunc(
             lib, "vkQueueFlushCommandsFromAuxMemoryGOOGLE");
     out->vkGetBlobGOOGLE = (PFN_vkGetBlobGOOGLE)dlSymFunc(lib, "vkGetBlobGOOGLE");
+    out->vkUpdateDescriptorSetWithTemplateSized2GOOGLE =
+        (PFN_vkUpdateDescriptorSetWithTemplateSized2GOOGLE)dlSymFunc(
+            lib, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE");
 #endif
 #ifdef VK_EXT_multi_draw
     out->vkCmdDrawMultiEXT = (PFN_vkCmdDrawMultiEXT)dlSymFunc(lib, "vkCmdDrawMultiEXT");
     out->vkCmdDrawMultiIndexedEXT =
         (PFN_vkCmdDrawMultiIndexedEXT)dlSymFunc(lib, "vkCmdDrawMultiIndexedEXT");
 #endif
+#ifdef VK_EXT_opacity_micromap
+    out->vkCreateMicromapEXT = (PFN_vkCreateMicromapEXT)dlSymFunc(lib, "vkCreateMicromapEXT");
+    out->vkDestroyMicromapEXT = (PFN_vkDestroyMicromapEXT)dlSymFunc(lib, "vkDestroyMicromapEXT");
+    out->vkCmdBuildMicromapsEXT =
+        (PFN_vkCmdBuildMicromapsEXT)dlSymFunc(lib, "vkCmdBuildMicromapsEXT");
+    out->vkBuildMicromapsEXT = (PFN_vkBuildMicromapsEXT)dlSymFunc(lib, "vkBuildMicromapsEXT");
+    out->vkCopyMicromapEXT = (PFN_vkCopyMicromapEXT)dlSymFunc(lib, "vkCopyMicromapEXT");
+    out->vkCopyMicromapToMemoryEXT =
+        (PFN_vkCopyMicromapToMemoryEXT)dlSymFunc(lib, "vkCopyMicromapToMemoryEXT");
+    out->vkCopyMemoryToMicromapEXT =
+        (PFN_vkCopyMemoryToMicromapEXT)dlSymFunc(lib, "vkCopyMemoryToMicromapEXT");
+    out->vkWriteMicromapsPropertiesEXT =
+        (PFN_vkWriteMicromapsPropertiesEXT)dlSymFunc(lib, "vkWriteMicromapsPropertiesEXT");
+    out->vkCmdCopyMicromapEXT = (PFN_vkCmdCopyMicromapEXT)dlSymFunc(lib, "vkCmdCopyMicromapEXT");
+    out->vkCmdCopyMicromapToMemoryEXT =
+        (PFN_vkCmdCopyMicromapToMemoryEXT)dlSymFunc(lib, "vkCmdCopyMicromapToMemoryEXT");
+    out->vkCmdCopyMemoryToMicromapEXT =
+        (PFN_vkCmdCopyMemoryToMicromapEXT)dlSymFunc(lib, "vkCmdCopyMemoryToMicromapEXT");
+    out->vkCmdWriteMicromapsPropertiesEXT =
+        (PFN_vkCmdWriteMicromapsPropertiesEXT)dlSymFunc(lib, "vkCmdWriteMicromapsPropertiesEXT");
+    out->vkGetDeviceMicromapCompatibilityEXT = (PFN_vkGetDeviceMicromapCompatibilityEXT)dlSymFunc(
+        lib, "vkGetDeviceMicromapCompatibilityEXT");
+    out->vkGetMicromapBuildSizesEXT =
+        (PFN_vkGetMicromapBuildSizesEXT)dlSymFunc(lib, "vkGetMicromapBuildSizesEXT");
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+    out->vkCmdDrawClusterHUAWEI =
+        (PFN_vkCmdDrawClusterHUAWEI)dlSymFunc(lib, "vkCmdDrawClusterHUAWEI");
+    out->vkCmdDrawClusterIndirectHUAWEI =
+        (PFN_vkCmdDrawClusterIndirectHUAWEI)dlSymFunc(lib, "vkCmdDrawClusterIndirectHUAWEI");
+#endif
 #ifdef VK_EXT_pageable_device_local_memory
     out->vkSetDeviceMemoryPriorityEXT =
         (PFN_vkSetDeviceMemoryPriorityEXT)dlSymFunc(lib, "vkSetDeviceMemoryPriorityEXT");
 #endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+    out->vkGetDescriptorSetLayoutHostMappingInfoVALVE =
+        (PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)dlSymFunc(
+            lib, "vkGetDescriptorSetLayoutHostMappingInfoVALVE");
+    out->vkGetDescriptorSetHostMappingVALVE = (PFN_vkGetDescriptorSetHostMappingVALVE)dlSymFunc(
+        lib, "vkGetDescriptorSetHostMappingVALVE");
+#endif
+#ifdef VK_NV_copy_memory_indirect
+    out->vkCmdCopyMemoryIndirectNV =
+        (PFN_vkCmdCopyMemoryIndirectNV)dlSymFunc(lib, "vkCmdCopyMemoryIndirectNV");
+    out->vkCmdCopyMemoryToImageIndirectNV =
+        (PFN_vkCmdCopyMemoryToImageIndirectNV)dlSymFunc(lib, "vkCmdCopyMemoryToImageIndirectNV");
+#endif
+#ifdef VK_NV_memory_decompression
+    out->vkCmdDecompressMemoryNV =
+        (PFN_vkCmdDecompressMemoryNV)dlSymFunc(lib, "vkCmdDecompressMemoryNV");
+    out->vkCmdDecompressMemoryIndirectCountNV = (PFN_vkCmdDecompressMemoryIndirectCountNV)dlSymFunc(
+        lib, "vkCmdDecompressMemoryIndirectCountNV");
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+    out->vkCmdSetTessellationDomainOriginEXT = (PFN_vkCmdSetTessellationDomainOriginEXT)dlSymFunc(
+        lib, "vkCmdSetTessellationDomainOriginEXT");
+    out->vkCmdSetDepthClampEnableEXT =
+        (PFN_vkCmdSetDepthClampEnableEXT)dlSymFunc(lib, "vkCmdSetDepthClampEnableEXT");
+    out->vkCmdSetPolygonModeEXT =
+        (PFN_vkCmdSetPolygonModeEXT)dlSymFunc(lib, "vkCmdSetPolygonModeEXT");
+    out->vkCmdSetRasterizationSamplesEXT =
+        (PFN_vkCmdSetRasterizationSamplesEXT)dlSymFunc(lib, "vkCmdSetRasterizationSamplesEXT");
+    out->vkCmdSetSampleMaskEXT = (PFN_vkCmdSetSampleMaskEXT)dlSymFunc(lib, "vkCmdSetSampleMaskEXT");
+    out->vkCmdSetAlphaToCoverageEnableEXT =
+        (PFN_vkCmdSetAlphaToCoverageEnableEXT)dlSymFunc(lib, "vkCmdSetAlphaToCoverageEnableEXT");
+    out->vkCmdSetAlphaToOneEnableEXT =
+        (PFN_vkCmdSetAlphaToOneEnableEXT)dlSymFunc(lib, "vkCmdSetAlphaToOneEnableEXT");
+    out->vkCmdSetLogicOpEnableEXT =
+        (PFN_vkCmdSetLogicOpEnableEXT)dlSymFunc(lib, "vkCmdSetLogicOpEnableEXT");
+    out->vkCmdSetColorBlendEnableEXT =
+        (PFN_vkCmdSetColorBlendEnableEXT)dlSymFunc(lib, "vkCmdSetColorBlendEnableEXT");
+    out->vkCmdSetColorBlendEquationEXT =
+        (PFN_vkCmdSetColorBlendEquationEXT)dlSymFunc(lib, "vkCmdSetColorBlendEquationEXT");
+    out->vkCmdSetColorWriteMaskEXT =
+        (PFN_vkCmdSetColorWriteMaskEXT)dlSymFunc(lib, "vkCmdSetColorWriteMaskEXT");
+    out->vkCmdSetRasterizationStreamEXT =
+        (PFN_vkCmdSetRasterizationStreamEXT)dlSymFunc(lib, "vkCmdSetRasterizationStreamEXT");
+    out->vkCmdSetConservativeRasterizationModeEXT =
+        (PFN_vkCmdSetConservativeRasterizationModeEXT)dlSymFunc(
+            lib, "vkCmdSetConservativeRasterizationModeEXT");
+    out->vkCmdSetExtraPrimitiveOverestimationSizeEXT =
+        (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)dlSymFunc(
+            lib, "vkCmdSetExtraPrimitiveOverestimationSizeEXT");
+    out->vkCmdSetDepthClipEnableEXT =
+        (PFN_vkCmdSetDepthClipEnableEXT)dlSymFunc(lib, "vkCmdSetDepthClipEnableEXT");
+    out->vkCmdSetSampleLocationsEnableEXT =
+        (PFN_vkCmdSetSampleLocationsEnableEXT)dlSymFunc(lib, "vkCmdSetSampleLocationsEnableEXT");
+    out->vkCmdSetColorBlendAdvancedEXT =
+        (PFN_vkCmdSetColorBlendAdvancedEXT)dlSymFunc(lib, "vkCmdSetColorBlendAdvancedEXT");
+    out->vkCmdSetProvokingVertexModeEXT =
+        (PFN_vkCmdSetProvokingVertexModeEXT)dlSymFunc(lib, "vkCmdSetProvokingVertexModeEXT");
+    out->vkCmdSetLineRasterizationModeEXT =
+        (PFN_vkCmdSetLineRasterizationModeEXT)dlSymFunc(lib, "vkCmdSetLineRasterizationModeEXT");
+    out->vkCmdSetLineStippleEnableEXT =
+        (PFN_vkCmdSetLineStippleEnableEXT)dlSymFunc(lib, "vkCmdSetLineStippleEnableEXT");
+    out->vkCmdSetDepthClipNegativeOneToOneEXT = (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)dlSymFunc(
+        lib, "vkCmdSetDepthClipNegativeOneToOneEXT");
+    out->vkCmdSetViewportWScalingEnableNV =
+        (PFN_vkCmdSetViewportWScalingEnableNV)dlSymFunc(lib, "vkCmdSetViewportWScalingEnableNV");
+    out->vkCmdSetViewportSwizzleNV =
+        (PFN_vkCmdSetViewportSwizzleNV)dlSymFunc(lib, "vkCmdSetViewportSwizzleNV");
+    out->vkCmdSetCoverageToColorEnableNV =
+        (PFN_vkCmdSetCoverageToColorEnableNV)dlSymFunc(lib, "vkCmdSetCoverageToColorEnableNV");
+    out->vkCmdSetCoverageToColorLocationNV =
+        (PFN_vkCmdSetCoverageToColorLocationNV)dlSymFunc(lib, "vkCmdSetCoverageToColorLocationNV");
+    out->vkCmdSetCoverageModulationModeNV =
+        (PFN_vkCmdSetCoverageModulationModeNV)dlSymFunc(lib, "vkCmdSetCoverageModulationModeNV");
+    out->vkCmdSetCoverageModulationTableEnableNV =
+        (PFN_vkCmdSetCoverageModulationTableEnableNV)dlSymFunc(
+            lib, "vkCmdSetCoverageModulationTableEnableNV");
+    out->vkCmdSetCoverageModulationTableNV =
+        (PFN_vkCmdSetCoverageModulationTableNV)dlSymFunc(lib, "vkCmdSetCoverageModulationTableNV");
+    out->vkCmdSetShadingRateImageEnableNV =
+        (PFN_vkCmdSetShadingRateImageEnableNV)dlSymFunc(lib, "vkCmdSetShadingRateImageEnableNV");
+    out->vkCmdSetRepresentativeFragmentTestEnableNV =
+        (PFN_vkCmdSetRepresentativeFragmentTestEnableNV)dlSymFunc(
+            lib, "vkCmdSetRepresentativeFragmentTestEnableNV");
+    out->vkCmdSetCoverageReductionModeNV =
+        (PFN_vkCmdSetCoverageReductionModeNV)dlSymFunc(lib, "vkCmdSetCoverageReductionModeNV");
+#endif
+#ifdef VK_EXT_shader_module_identifier
+    out->vkGetShaderModuleIdentifierEXT =
+        (PFN_vkGetShaderModuleIdentifierEXT)dlSymFunc(lib, "vkGetShaderModuleIdentifierEXT");
+    out->vkGetShaderModuleCreateInfoIdentifierEXT =
+        (PFN_vkGetShaderModuleCreateInfoIdentifierEXT)dlSymFunc(
+            lib, "vkGetShaderModuleCreateInfoIdentifierEXT");
+#endif
+#ifdef VK_NV_optical_flow
+    out->vkGetPhysicalDeviceOpticalFlowImageFormatsNV =
+        (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)dlSymFunc(
+            lib, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV");
+    out->vkCreateOpticalFlowSessionNV =
+        (PFN_vkCreateOpticalFlowSessionNV)dlSymFunc(lib, "vkCreateOpticalFlowSessionNV");
+    out->vkDestroyOpticalFlowSessionNV =
+        (PFN_vkDestroyOpticalFlowSessionNV)dlSymFunc(lib, "vkDestroyOpticalFlowSessionNV");
+    out->vkBindOpticalFlowSessionImageNV =
+        (PFN_vkBindOpticalFlowSessionImageNV)dlSymFunc(lib, "vkBindOpticalFlowSessionImageNV");
+    out->vkCmdOpticalFlowExecuteNV =
+        (PFN_vkCmdOpticalFlowExecuteNV)dlSymFunc(lib, "vkCmdOpticalFlowExecuteNV");
+#endif
+#ifdef VK_EXT_shader_object
+    out->vkCreateShadersEXT = (PFN_vkCreateShadersEXT)dlSymFunc(lib, "vkCreateShadersEXT");
+    out->vkDestroyShaderEXT = (PFN_vkDestroyShaderEXT)dlSymFunc(lib, "vkDestroyShaderEXT");
+    out->vkGetShaderBinaryDataEXT =
+        (PFN_vkGetShaderBinaryDataEXT)dlSymFunc(lib, "vkGetShaderBinaryDataEXT");
+    out->vkCmdBindShadersEXT = (PFN_vkCmdBindShadersEXT)dlSymFunc(lib, "vkCmdBindShadersEXT");
+#endif
+#ifdef VK_QCOM_tile_properties
+    out->vkGetFramebufferTilePropertiesQCOM = (PFN_vkGetFramebufferTilePropertiesQCOM)dlSymFunc(
+        lib, "vkGetFramebufferTilePropertiesQCOM");
+    out->vkGetDynamicRenderingTilePropertiesQCOM =
+        (PFN_vkGetDynamicRenderingTilePropertiesQCOM)dlSymFunc(
+            lib, "vkGetDynamicRenderingTilePropertiesQCOM");
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+    out->vkCmdSetAttachmentFeedbackLoopEnableEXT =
+        (PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT)dlSymFunc(
+            lib, "vkCmdSetAttachmentFeedbackLoopEnableEXT");
+#endif
 #ifdef VK_KHR_acceleration_structure
     out->vkCreateAccelerationStructureKHR =
         (PFN_vkCreateAccelerationStructureKHR)dlSymFunc(lib, "vkCreateAccelerationStructureKHR");
@@ -1835,13 +2242,12 @@ void init_vulkan_dispatch_from_system_loader(DlOpenFunc dlOpenFunc, DlSymFunc dl
         (PFN_vkCmdSetRayTracingPipelineStackSizeKHR)dlSymFunc(
             lib, "vkCmdSetRayTracingPipelineStackSizeKHR");
 #endif
-#ifdef VK_MVK_moltenvk
-    out->vkGetMTLDeviceMVK = (PFN_vkGetMTLDeviceMVK)dlSymFunc(lib, "vkGetMTLDeviceMVK");
-    out->vkSetMTLTextureMVK = (PFN_vkSetMTLTextureMVK)dlSymFunc(lib, "vkSetMTLTextureMVK");
-    out->vkGetMTLTextureMVK = (PFN_vkGetMTLTextureMVK)dlSymFunc(lib, "vkGetMTLTextureMVK");
-    out->vkGetMTLBufferMVK = (PFN_vkGetMTLBufferMVK)dlSymFunc(lib, "vkGetMTLBufferMVK");
-    out->vkUseIOSurfaceMVK = (PFN_vkUseIOSurfaceMVK)dlSymFunc(lib, "vkUseIOSurfaceMVK");
-    out->vkGetIOSurfaceMVK = (PFN_vkGetIOSurfaceMVK)dlSymFunc(lib, "vkGetIOSurfaceMVK");
+#ifdef VK_EXT_mesh_shader
+    out->vkCmdDrawMeshTasksEXT = (PFN_vkCmdDrawMeshTasksEXT)dlSymFunc(lib, "vkCmdDrawMeshTasksEXT");
+    out->vkCmdDrawMeshTasksIndirectEXT =
+        (PFN_vkCmdDrawMeshTasksIndirectEXT)dlSymFunc(lib, "vkCmdDrawMeshTasksIndirectEXT");
+    out->vkCmdDrawMeshTasksIndirectCountEXT = (PFN_vkCmdDrawMeshTasksIndirectCountEXT)dlSymFunc(
+        lib, "vkCmdDrawMeshTasksIndirectCountEXT");
 #endif
 }
 
@@ -2342,6 +2748,87 @@ void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
         (PFN_vkGetDeviceMemoryOpaqueCaptureAddress)vk->vkGetInstanceProcAddr(
             instance, "vkGetDeviceMemoryOpaqueCaptureAddress");
 #endif
+#ifdef VK_VERSION_1_3
+    out->vkGetPhysicalDeviceToolProperties =
+        (PFN_vkGetPhysicalDeviceToolProperties)vk->vkGetInstanceProcAddr(
+            instance, "vkGetPhysicalDeviceToolProperties");
+    out->vkCreatePrivateDataSlot =
+        (PFN_vkCreatePrivateDataSlot)vk->vkGetInstanceProcAddr(instance, "vkCreatePrivateDataSlot");
+    out->vkDestroyPrivateDataSlot = (PFN_vkDestroyPrivateDataSlot)vk->vkGetInstanceProcAddr(
+        instance, "vkDestroyPrivateDataSlot");
+    out->vkSetPrivateData =
+        (PFN_vkSetPrivateData)vk->vkGetInstanceProcAddr(instance, "vkSetPrivateData");
+    out->vkGetPrivateData =
+        (PFN_vkGetPrivateData)vk->vkGetInstanceProcAddr(instance, "vkGetPrivateData");
+    out->vkCmdSetEvent2 = (PFN_vkCmdSetEvent2)vk->vkGetInstanceProcAddr(instance, "vkCmdSetEvent2");
+    out->vkCmdResetEvent2 =
+        (PFN_vkCmdResetEvent2)vk->vkGetInstanceProcAddr(instance, "vkCmdResetEvent2");
+    out->vkCmdWaitEvents2 =
+        (PFN_vkCmdWaitEvents2)vk->vkGetInstanceProcAddr(instance, "vkCmdWaitEvents2");
+    out->vkCmdPipelineBarrier2 =
+        (PFN_vkCmdPipelineBarrier2)vk->vkGetInstanceProcAddr(instance, "vkCmdPipelineBarrier2");
+    out->vkCmdWriteTimestamp2 =
+        (PFN_vkCmdWriteTimestamp2)vk->vkGetInstanceProcAddr(instance, "vkCmdWriteTimestamp2");
+    out->vkQueueSubmit2 = (PFN_vkQueueSubmit2)vk->vkGetInstanceProcAddr(instance, "vkQueueSubmit2");
+    out->vkCmdCopyBuffer2 =
+        (PFN_vkCmdCopyBuffer2)vk->vkGetInstanceProcAddr(instance, "vkCmdCopyBuffer2");
+    out->vkCmdCopyImage2 =
+        (PFN_vkCmdCopyImage2)vk->vkGetInstanceProcAddr(instance, "vkCmdCopyImage2");
+    out->vkCmdCopyBufferToImage2 =
+        (PFN_vkCmdCopyBufferToImage2)vk->vkGetInstanceProcAddr(instance, "vkCmdCopyBufferToImage2");
+    out->vkCmdCopyImageToBuffer2 =
+        (PFN_vkCmdCopyImageToBuffer2)vk->vkGetInstanceProcAddr(instance, "vkCmdCopyImageToBuffer2");
+    out->vkCmdBlitImage2 =
+        (PFN_vkCmdBlitImage2)vk->vkGetInstanceProcAddr(instance, "vkCmdBlitImage2");
+    out->vkCmdResolveImage2 =
+        (PFN_vkCmdResolveImage2)vk->vkGetInstanceProcAddr(instance, "vkCmdResolveImage2");
+    out->vkCmdBeginRendering =
+        (PFN_vkCmdBeginRendering)vk->vkGetInstanceProcAddr(instance, "vkCmdBeginRendering");
+    out->vkCmdEndRendering =
+        (PFN_vkCmdEndRendering)vk->vkGetInstanceProcAddr(instance, "vkCmdEndRendering");
+    out->vkCmdSetCullMode =
+        (PFN_vkCmdSetCullMode)vk->vkGetInstanceProcAddr(instance, "vkCmdSetCullMode");
+    out->vkCmdSetFrontFace =
+        (PFN_vkCmdSetFrontFace)vk->vkGetInstanceProcAddr(instance, "vkCmdSetFrontFace");
+    out->vkCmdSetPrimitiveTopology = (PFN_vkCmdSetPrimitiveTopology)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdSetPrimitiveTopology");
+    out->vkCmdSetViewportWithCount = (PFN_vkCmdSetViewportWithCount)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdSetViewportWithCount");
+    out->vkCmdSetScissorWithCount = (PFN_vkCmdSetScissorWithCount)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdSetScissorWithCount");
+    out->vkCmdBindVertexBuffers2 =
+        (PFN_vkCmdBindVertexBuffers2)vk->vkGetInstanceProcAddr(instance, "vkCmdBindVertexBuffers2");
+    out->vkCmdSetDepthTestEnable =
+        (PFN_vkCmdSetDepthTestEnable)vk->vkGetInstanceProcAddr(instance, "vkCmdSetDepthTestEnable");
+    out->vkCmdSetDepthWriteEnable = (PFN_vkCmdSetDepthWriteEnable)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdSetDepthWriteEnable");
+    out->vkCmdSetDepthCompareOp =
+        (PFN_vkCmdSetDepthCompareOp)vk->vkGetInstanceProcAddr(instance, "vkCmdSetDepthCompareOp");
+    out->vkCmdSetDepthBoundsTestEnable =
+        (PFN_vkCmdSetDepthBoundsTestEnable)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetDepthBoundsTestEnable");
+    out->vkCmdSetStencilTestEnable = (PFN_vkCmdSetStencilTestEnable)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdSetStencilTestEnable");
+    out->vkCmdSetStencilOp =
+        (PFN_vkCmdSetStencilOp)vk->vkGetInstanceProcAddr(instance, "vkCmdSetStencilOp");
+    out->vkCmdSetRasterizerDiscardEnable =
+        (PFN_vkCmdSetRasterizerDiscardEnable)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetRasterizerDiscardEnable");
+    out->vkCmdSetDepthBiasEnable =
+        (PFN_vkCmdSetDepthBiasEnable)vk->vkGetInstanceProcAddr(instance, "vkCmdSetDepthBiasEnable");
+    out->vkCmdSetPrimitiveRestartEnable =
+        (PFN_vkCmdSetPrimitiveRestartEnable)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetPrimitiveRestartEnable");
+    out->vkGetDeviceBufferMemoryRequirements =
+        (PFN_vkGetDeviceBufferMemoryRequirements)vk->vkGetInstanceProcAddr(
+            instance, "vkGetDeviceBufferMemoryRequirements");
+    out->vkGetDeviceImageMemoryRequirements =
+        (PFN_vkGetDeviceImageMemoryRequirements)vk->vkGetInstanceProcAddr(
+            instance, "vkGetDeviceImageMemoryRequirements");
+    out->vkGetDeviceImageSparseMemoryRequirements =
+        (PFN_vkGetDeviceImageSparseMemoryRequirements)vk->vkGetInstanceProcAddr(
+            instance, "vkGetDeviceImageSparseMemoryRequirements");
+#endif
 #ifdef VK_KHR_surface
     out->vkGetPhysicalDeviceSurfaceSupportKHR =
         (PFN_vkGetPhysicalDeviceSurfaceSupportKHR)vk->vkGetInstanceProcAddr(
@@ -2689,6 +3176,12 @@ void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
         (PFN_vkGetPipelineExecutableInternalRepresentationsKHR)vk->vkGetInstanceProcAddr(
             instance, "vkGetPipelineExecutableInternalRepresentationsKHR");
 #endif
+#ifdef VK_KHR_map_memory2
+    out->vkMapMemory2KHR =
+        (PFN_vkMapMemory2KHR)vk->vkGetInstanceProcAddr(instance, "vkMapMemory2KHR");
+    out->vkUnmapMemory2KHR =
+        (PFN_vkUnmapMemory2KHR)vk->vkGetInstanceProcAddr(instance, "vkUnmapMemory2KHR");
+#endif
 #ifdef VK_KHR_video_encode_queue
     out->vkCmdEncodeVideoKHR =
         (PFN_vkCmdEncodeVideoKHR)vk->vkGetInstanceProcAddr(instance, "vkCmdEncodeVideoKHR");
@@ -2725,6 +3218,10 @@ void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
     out->vkCmdResolveImage2KHR =
         (PFN_vkCmdResolveImage2KHR)vk->vkGetInstanceProcAddr(instance, "vkCmdResolveImage2KHR");
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+    out->vkCmdTraceRaysIndirect2KHR = (PFN_vkCmdTraceRaysIndirect2KHR)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdTraceRaysIndirect2KHR");
+#endif
 #ifdef VK_KHR_maintenance4
     out->vkGetDeviceBufferMemoryRequirementsKHR =
         (PFN_vkGetDeviceBufferMemoryRequirementsKHR)vk->vkGetInstanceProcAddr(
@@ -2745,6 +3242,9 @@ void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
     out->vkQueueSignalReleaseImageANDROID =
         (PFN_vkQueueSignalReleaseImageANDROID)vk->vkGetInstanceProcAddr(
             instance, "vkQueueSignalReleaseImageANDROID");
+    out->vkGetSwapchainGrallocUsage2ANDROID =
+        (PFN_vkGetSwapchainGrallocUsage2ANDROID)vk->vkGetInstanceProcAddr(
+            instance, "vkGetSwapchainGrallocUsage2ANDROID");
 #endif
 #ifdef VK_EXT_debug_marker
     out->vkDebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)vk->vkGetInstanceProcAddr(
@@ -2862,6 +3362,12 @@ void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
 #ifdef VK_EXT_discard_rectangles
     out->vkCmdSetDiscardRectangleEXT = (PFN_vkCmdSetDiscardRectangleEXT)vk->vkGetInstanceProcAddr(
         instance, "vkCmdSetDiscardRectangleEXT");
+    out->vkCmdSetDiscardRectangleEnableEXT =
+        (PFN_vkCmdSetDiscardRectangleEnableEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetDiscardRectangleEnableEXT");
+    out->vkCmdSetDiscardRectangleModeEXT =
+        (PFN_vkCmdSetDiscardRectangleModeEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetDiscardRectangleModeEXT");
 #endif
 #ifdef VK_EXT_hdr_metadata
     out->vkSetHdrMetadataEXT =
@@ -2992,6 +3498,9 @@ void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
             instance, "vkCmdDrawMeshTasksIndirectCountNV");
 #endif
 #ifdef VK_NV_scissor_exclusive
+    out->vkCmdSetExclusiveScissorEnableNV =
+        (PFN_vkCmdSetExclusiveScissorEnableNV)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetExclusiveScissorEnableNV");
     out->vkCmdSetExclusiveScissorNV = (PFN_vkCmdSetExclusiveScissorNV)vk->vkGetInstanceProcAddr(
         instance, "vkCmdSetExclusiveScissorNV");
 #endif
@@ -3103,6 +3612,10 @@ void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
     out->vkCmdSetStencilOpEXT =
         (PFN_vkCmdSetStencilOpEXT)vk->vkGetInstanceProcAddr(instance, "vkCmdSetStencilOpEXT");
 #endif
+#ifdef VK_EXT_swapchain_maintenance1
+    out->vkReleaseSwapchainImagesEXT = (PFN_vkReleaseSwapchainImagesEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkReleaseSwapchainImagesEXT");
+#endif
 #ifdef VK_NV_device_generated_commands
     out->vkGetGeneratedCommandsMemoryRequirementsNV =
         (PFN_vkGetGeneratedCommandsMemoryRequirementsNV)vk->vkGetInstanceProcAddr(
@@ -3139,11 +3652,58 @@ void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
     out->vkGetPrivateDataEXT =
         (PFN_vkGetPrivateDataEXT)vk->vkGetInstanceProcAddr(instance, "vkGetPrivateDataEXT");
 #endif
+#ifdef VK_EXT_metal_objects
+    out->vkExportMetalObjectsEXT =
+        (PFN_vkExportMetalObjectsEXT)vk->vkGetInstanceProcAddr(instance, "vkExportMetalObjectsEXT");
+#endif
+#ifdef VK_EXT_descriptor_buffer
+    out->vkGetDescriptorSetLayoutSizeEXT =
+        (PFN_vkGetDescriptorSetLayoutSizeEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkGetDescriptorSetLayoutSizeEXT");
+    out->vkGetDescriptorSetLayoutBindingOffsetEXT =
+        (PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkGetDescriptorSetLayoutBindingOffsetEXT");
+    out->vkGetDescriptorEXT =
+        (PFN_vkGetDescriptorEXT)vk->vkGetInstanceProcAddr(instance, "vkGetDescriptorEXT");
+    out->vkCmdBindDescriptorBuffersEXT =
+        (PFN_vkCmdBindDescriptorBuffersEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdBindDescriptorBuffersEXT");
+    out->vkCmdSetDescriptorBufferOffsetsEXT =
+        (PFN_vkCmdSetDescriptorBufferOffsetsEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetDescriptorBufferOffsetsEXT");
+    out->vkCmdBindDescriptorBufferEmbeddedSamplersEXT =
+        (PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT");
+    out->vkGetBufferOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkGetBufferOpaqueCaptureDescriptorDataEXT");
+    out->vkGetImageOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkGetImageOpaqueCaptureDescriptorDataEXT");
+    out->vkGetImageViewOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkGetImageViewOpaqueCaptureDescriptorDataEXT");
+    out->vkGetSamplerOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkGetSamplerOpaqueCaptureDescriptorDataEXT");
+    out->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT");
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
     out->vkCmdSetFragmentShadingRateEnumNV =
         (PFN_vkCmdSetFragmentShadingRateEnumNV)vk->vkGetInstanceProcAddr(
             instance, "vkCmdSetFragmentShadingRateEnumNV");
 #endif
+#ifdef VK_EXT_image_compression_control
+    out->vkGetImageSubresourceLayout2EXT =
+        (PFN_vkGetImageSubresourceLayout2EXT)vk->vkGetInstanceProcAddr(
+            instance, "vkGetImageSubresourceLayout2EXT");
+#endif
+#ifdef VK_EXT_device_fault
+    out->vkGetDeviceFaultInfoEXT =
+        (PFN_vkGetDeviceFaultInfoEXT)vk->vkGetInstanceProcAddr(instance, "vkGetDeviceFaultInfoEXT");
+#endif
 #ifdef VK_NV_acquire_winrt_display
     out->vkAcquireWinrtDisplayNV =
         (PFN_vkAcquireWinrtDisplayNV)vk->vkGetInstanceProcAddr(instance, "vkAcquireWinrtDisplayNV");
@@ -3208,6 +3768,10 @@ void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
     out->vkGetMemoryRemoteAddressNV = (PFN_vkGetMemoryRemoteAddressNV)vk->vkGetInstanceProcAddr(
         instance, "vkGetMemoryRemoteAddressNV");
 #endif
+#ifdef VK_EXT_pipeline_properties
+    out->vkGetPipelinePropertiesEXT = (PFN_vkGetPipelinePropertiesEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkGetPipelinePropertiesEXT");
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
     out->vkCmdSetPatchControlPointsEXT =
         (PFN_vkCmdSetPatchControlPointsEXT)vk->vkGetInstanceProcAddr(
@@ -3291,6 +3855,9 @@ void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
             instance, "vkQueueFlushCommandsFromAuxMemoryGOOGLE");
     out->vkGetBlobGOOGLE =
         (PFN_vkGetBlobGOOGLE)vk->vkGetInstanceProcAddr(instance, "vkGetBlobGOOGLE");
+    out->vkUpdateDescriptorSetWithTemplateSized2GOOGLE =
+        (PFN_vkUpdateDescriptorSetWithTemplateSized2GOOGLE)vk->vkGetInstanceProcAddr(
+            instance, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE");
 #endif
 #ifdef VK_EXT_multi_draw
     out->vkCmdDrawMultiEXT =
@@ -3298,10 +3865,203 @@ void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
     out->vkCmdDrawMultiIndexedEXT = (PFN_vkCmdDrawMultiIndexedEXT)vk->vkGetInstanceProcAddr(
         instance, "vkCmdDrawMultiIndexedEXT");
 #endif
+#ifdef VK_EXT_opacity_micromap
+    out->vkCreateMicromapEXT =
+        (PFN_vkCreateMicromapEXT)vk->vkGetInstanceProcAddr(instance, "vkCreateMicromapEXT");
+    out->vkDestroyMicromapEXT =
+        (PFN_vkDestroyMicromapEXT)vk->vkGetInstanceProcAddr(instance, "vkDestroyMicromapEXT");
+    out->vkCmdBuildMicromapsEXT =
+        (PFN_vkCmdBuildMicromapsEXT)vk->vkGetInstanceProcAddr(instance, "vkCmdBuildMicromapsEXT");
+    out->vkBuildMicromapsEXT =
+        (PFN_vkBuildMicromapsEXT)vk->vkGetInstanceProcAddr(instance, "vkBuildMicromapsEXT");
+    out->vkCopyMicromapEXT =
+        (PFN_vkCopyMicromapEXT)vk->vkGetInstanceProcAddr(instance, "vkCopyMicromapEXT");
+    out->vkCopyMicromapToMemoryEXT = (PFN_vkCopyMicromapToMemoryEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkCopyMicromapToMemoryEXT");
+    out->vkCopyMemoryToMicromapEXT = (PFN_vkCopyMemoryToMicromapEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkCopyMemoryToMicromapEXT");
+    out->vkWriteMicromapsPropertiesEXT =
+        (PFN_vkWriteMicromapsPropertiesEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkWriteMicromapsPropertiesEXT");
+    out->vkCmdCopyMicromapEXT =
+        (PFN_vkCmdCopyMicromapEXT)vk->vkGetInstanceProcAddr(instance, "vkCmdCopyMicromapEXT");
+    out->vkCmdCopyMicromapToMemoryEXT = (PFN_vkCmdCopyMicromapToMemoryEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdCopyMicromapToMemoryEXT");
+    out->vkCmdCopyMemoryToMicromapEXT = (PFN_vkCmdCopyMemoryToMicromapEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdCopyMemoryToMicromapEXT");
+    out->vkCmdWriteMicromapsPropertiesEXT =
+        (PFN_vkCmdWriteMicromapsPropertiesEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdWriteMicromapsPropertiesEXT");
+    out->vkGetDeviceMicromapCompatibilityEXT =
+        (PFN_vkGetDeviceMicromapCompatibilityEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkGetDeviceMicromapCompatibilityEXT");
+    out->vkGetMicromapBuildSizesEXT = (PFN_vkGetMicromapBuildSizesEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkGetMicromapBuildSizesEXT");
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+    out->vkCmdDrawClusterHUAWEI =
+        (PFN_vkCmdDrawClusterHUAWEI)vk->vkGetInstanceProcAddr(instance, "vkCmdDrawClusterHUAWEI");
+    out->vkCmdDrawClusterIndirectHUAWEI =
+        (PFN_vkCmdDrawClusterIndirectHUAWEI)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdDrawClusterIndirectHUAWEI");
+#endif
 #ifdef VK_EXT_pageable_device_local_memory
     out->vkSetDeviceMemoryPriorityEXT = (PFN_vkSetDeviceMemoryPriorityEXT)vk->vkGetInstanceProcAddr(
         instance, "vkSetDeviceMemoryPriorityEXT");
 #endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+    out->vkGetDescriptorSetLayoutHostMappingInfoVALVE =
+        (PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)vk->vkGetInstanceProcAddr(
+            instance, "vkGetDescriptorSetLayoutHostMappingInfoVALVE");
+    out->vkGetDescriptorSetHostMappingVALVE =
+        (PFN_vkGetDescriptorSetHostMappingVALVE)vk->vkGetInstanceProcAddr(
+            instance, "vkGetDescriptorSetHostMappingVALVE");
+#endif
+#ifdef VK_NV_copy_memory_indirect
+    out->vkCmdCopyMemoryIndirectNV = (PFN_vkCmdCopyMemoryIndirectNV)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdCopyMemoryIndirectNV");
+    out->vkCmdCopyMemoryToImageIndirectNV =
+        (PFN_vkCmdCopyMemoryToImageIndirectNV)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdCopyMemoryToImageIndirectNV");
+#endif
+#ifdef VK_NV_memory_decompression
+    out->vkCmdDecompressMemoryNV =
+        (PFN_vkCmdDecompressMemoryNV)vk->vkGetInstanceProcAddr(instance, "vkCmdDecompressMemoryNV");
+    out->vkCmdDecompressMemoryIndirectCountNV =
+        (PFN_vkCmdDecompressMemoryIndirectCountNV)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdDecompressMemoryIndirectCountNV");
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+    out->vkCmdSetTessellationDomainOriginEXT =
+        (PFN_vkCmdSetTessellationDomainOriginEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetTessellationDomainOriginEXT");
+    out->vkCmdSetDepthClampEnableEXT = (PFN_vkCmdSetDepthClampEnableEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdSetDepthClampEnableEXT");
+    out->vkCmdSetPolygonModeEXT =
+        (PFN_vkCmdSetPolygonModeEXT)vk->vkGetInstanceProcAddr(instance, "vkCmdSetPolygonModeEXT");
+    out->vkCmdSetRasterizationSamplesEXT =
+        (PFN_vkCmdSetRasterizationSamplesEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetRasterizationSamplesEXT");
+    out->vkCmdSetSampleMaskEXT =
+        (PFN_vkCmdSetSampleMaskEXT)vk->vkGetInstanceProcAddr(instance, "vkCmdSetSampleMaskEXT");
+    out->vkCmdSetAlphaToCoverageEnableEXT =
+        (PFN_vkCmdSetAlphaToCoverageEnableEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetAlphaToCoverageEnableEXT");
+    out->vkCmdSetAlphaToOneEnableEXT = (PFN_vkCmdSetAlphaToOneEnableEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdSetAlphaToOneEnableEXT");
+    out->vkCmdSetLogicOpEnableEXT = (PFN_vkCmdSetLogicOpEnableEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdSetLogicOpEnableEXT");
+    out->vkCmdSetColorBlendEnableEXT = (PFN_vkCmdSetColorBlendEnableEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdSetColorBlendEnableEXT");
+    out->vkCmdSetColorBlendEquationEXT =
+        (PFN_vkCmdSetColorBlendEquationEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetColorBlendEquationEXT");
+    out->vkCmdSetColorWriteMaskEXT = (PFN_vkCmdSetColorWriteMaskEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdSetColorWriteMaskEXT");
+    out->vkCmdSetRasterizationStreamEXT =
+        (PFN_vkCmdSetRasterizationStreamEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetRasterizationStreamEXT");
+    out->vkCmdSetConservativeRasterizationModeEXT =
+        (PFN_vkCmdSetConservativeRasterizationModeEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetConservativeRasterizationModeEXT");
+    out->vkCmdSetExtraPrimitiveOverestimationSizeEXT =
+        (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetExtraPrimitiveOverestimationSizeEXT");
+    out->vkCmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdSetDepthClipEnableEXT");
+    out->vkCmdSetSampleLocationsEnableEXT =
+        (PFN_vkCmdSetSampleLocationsEnableEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetSampleLocationsEnableEXT");
+    out->vkCmdSetColorBlendAdvancedEXT =
+        (PFN_vkCmdSetColorBlendAdvancedEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetColorBlendAdvancedEXT");
+    out->vkCmdSetProvokingVertexModeEXT =
+        (PFN_vkCmdSetProvokingVertexModeEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetProvokingVertexModeEXT");
+    out->vkCmdSetLineRasterizationModeEXT =
+        (PFN_vkCmdSetLineRasterizationModeEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetLineRasterizationModeEXT");
+    out->vkCmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdSetLineStippleEnableEXT");
+    out->vkCmdSetDepthClipNegativeOneToOneEXT =
+        (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetDepthClipNegativeOneToOneEXT");
+    out->vkCmdSetViewportWScalingEnableNV =
+        (PFN_vkCmdSetViewportWScalingEnableNV)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetViewportWScalingEnableNV");
+    out->vkCmdSetViewportSwizzleNV = (PFN_vkCmdSetViewportSwizzleNV)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdSetViewportSwizzleNV");
+    out->vkCmdSetCoverageToColorEnableNV =
+        (PFN_vkCmdSetCoverageToColorEnableNV)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetCoverageToColorEnableNV");
+    out->vkCmdSetCoverageToColorLocationNV =
+        (PFN_vkCmdSetCoverageToColorLocationNV)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetCoverageToColorLocationNV");
+    out->vkCmdSetCoverageModulationModeNV =
+        (PFN_vkCmdSetCoverageModulationModeNV)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetCoverageModulationModeNV");
+    out->vkCmdSetCoverageModulationTableEnableNV =
+        (PFN_vkCmdSetCoverageModulationTableEnableNV)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetCoverageModulationTableEnableNV");
+    out->vkCmdSetCoverageModulationTableNV =
+        (PFN_vkCmdSetCoverageModulationTableNV)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetCoverageModulationTableNV");
+    out->vkCmdSetShadingRateImageEnableNV =
+        (PFN_vkCmdSetShadingRateImageEnableNV)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetShadingRateImageEnableNV");
+    out->vkCmdSetRepresentativeFragmentTestEnableNV =
+        (PFN_vkCmdSetRepresentativeFragmentTestEnableNV)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetRepresentativeFragmentTestEnableNV");
+    out->vkCmdSetCoverageReductionModeNV =
+        (PFN_vkCmdSetCoverageReductionModeNV)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetCoverageReductionModeNV");
+#endif
+#ifdef VK_EXT_shader_module_identifier
+    out->vkGetShaderModuleIdentifierEXT =
+        (PFN_vkGetShaderModuleIdentifierEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkGetShaderModuleIdentifierEXT");
+    out->vkGetShaderModuleCreateInfoIdentifierEXT =
+        (PFN_vkGetShaderModuleCreateInfoIdentifierEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkGetShaderModuleCreateInfoIdentifierEXT");
+#endif
+#ifdef VK_NV_optical_flow
+    out->vkGetPhysicalDeviceOpticalFlowImageFormatsNV =
+        (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)vk->vkGetInstanceProcAddr(
+            instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV");
+    out->vkCreateOpticalFlowSessionNV = (PFN_vkCreateOpticalFlowSessionNV)vk->vkGetInstanceProcAddr(
+        instance, "vkCreateOpticalFlowSessionNV");
+    out->vkDestroyOpticalFlowSessionNV =
+        (PFN_vkDestroyOpticalFlowSessionNV)vk->vkGetInstanceProcAddr(
+            instance, "vkDestroyOpticalFlowSessionNV");
+    out->vkBindOpticalFlowSessionImageNV =
+        (PFN_vkBindOpticalFlowSessionImageNV)vk->vkGetInstanceProcAddr(
+            instance, "vkBindOpticalFlowSessionImageNV");
+    out->vkCmdOpticalFlowExecuteNV = (PFN_vkCmdOpticalFlowExecuteNV)vk->vkGetInstanceProcAddr(
+        instance, "vkCmdOpticalFlowExecuteNV");
+#endif
+#ifdef VK_EXT_shader_object
+    out->vkCreateShadersEXT =
+        (PFN_vkCreateShadersEXT)vk->vkGetInstanceProcAddr(instance, "vkCreateShadersEXT");
+    out->vkDestroyShaderEXT =
+        (PFN_vkDestroyShaderEXT)vk->vkGetInstanceProcAddr(instance, "vkDestroyShaderEXT");
+    out->vkGetShaderBinaryDataEXT = (PFN_vkGetShaderBinaryDataEXT)vk->vkGetInstanceProcAddr(
+        instance, "vkGetShaderBinaryDataEXT");
+    out->vkCmdBindShadersEXT =
+        (PFN_vkCmdBindShadersEXT)vk->vkGetInstanceProcAddr(instance, "vkCmdBindShadersEXT");
+#endif
+#ifdef VK_QCOM_tile_properties
+    out->vkGetFramebufferTilePropertiesQCOM =
+        (PFN_vkGetFramebufferTilePropertiesQCOM)vk->vkGetInstanceProcAddr(
+            instance, "vkGetFramebufferTilePropertiesQCOM");
+    out->vkGetDynamicRenderingTilePropertiesQCOM =
+        (PFN_vkGetDynamicRenderingTilePropertiesQCOM)vk->vkGetInstanceProcAddr(
+            instance, "vkGetDynamicRenderingTilePropertiesQCOM");
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+    out->vkCmdSetAttachmentFeedbackLoopEnableEXT =
+        (PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdSetAttachmentFeedbackLoopEnableEXT");
+#endif
 #ifdef VK_KHR_acceleration_structure
     out->vkCreateAccelerationStructureKHR =
         (PFN_vkCreateAccelerationStructureKHR)vk->vkGetInstanceProcAddr(
@@ -3370,6 +4130,16 @@ void init_vulkan_dispatch_from_instance(VulkanDispatch* vk, VkInstance instance,
         (PFN_vkCmdSetRayTracingPipelineStackSizeKHR)vk->vkGetInstanceProcAddr(
             instance, "vkCmdSetRayTracingPipelineStackSizeKHR");
 #endif
+#ifdef VK_EXT_mesh_shader
+    out->vkCmdDrawMeshTasksEXT =
+        (PFN_vkCmdDrawMeshTasksEXT)vk->vkGetInstanceProcAddr(instance, "vkCmdDrawMeshTasksEXT");
+    out->vkCmdDrawMeshTasksIndirectEXT =
+        (PFN_vkCmdDrawMeshTasksIndirectEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdDrawMeshTasksIndirectEXT");
+    out->vkCmdDrawMeshTasksIndirectCountEXT =
+        (PFN_vkCmdDrawMeshTasksIndirectCountEXT)vk->vkGetInstanceProcAddr(
+            instance, "vkCmdDrawMeshTasksIndirectCountEXT");
+#endif
 }
 
 void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, VulkanDispatch* out) {
@@ -3853,6 +4623,84 @@ void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, Vulka
         (PFN_vkGetDeviceMemoryOpaqueCaptureAddress)vk->vkGetDeviceProcAddr(
             device, "vkGetDeviceMemoryOpaqueCaptureAddress");
 #endif
+#ifdef VK_VERSION_1_3
+    out->vkGetPhysicalDeviceToolProperties =
+        (PFN_vkGetPhysicalDeviceToolProperties)vk->vkGetDeviceProcAddr(
+            device, "vkGetPhysicalDeviceToolProperties");
+    out->vkCreatePrivateDataSlot =
+        (PFN_vkCreatePrivateDataSlot)vk->vkGetDeviceProcAddr(device, "vkCreatePrivateDataSlot");
+    out->vkDestroyPrivateDataSlot =
+        (PFN_vkDestroyPrivateDataSlot)vk->vkGetDeviceProcAddr(device, "vkDestroyPrivateDataSlot");
+    out->vkSetPrivateData =
+        (PFN_vkSetPrivateData)vk->vkGetDeviceProcAddr(device, "vkSetPrivateData");
+    out->vkGetPrivateData =
+        (PFN_vkGetPrivateData)vk->vkGetDeviceProcAddr(device, "vkGetPrivateData");
+    out->vkCmdSetEvent2 = (PFN_vkCmdSetEvent2)vk->vkGetDeviceProcAddr(device, "vkCmdSetEvent2");
+    out->vkCmdResetEvent2 =
+        (PFN_vkCmdResetEvent2)vk->vkGetDeviceProcAddr(device, "vkCmdResetEvent2");
+    out->vkCmdWaitEvents2 =
+        (PFN_vkCmdWaitEvents2)vk->vkGetDeviceProcAddr(device, "vkCmdWaitEvents2");
+    out->vkCmdPipelineBarrier2 =
+        (PFN_vkCmdPipelineBarrier2)vk->vkGetDeviceProcAddr(device, "vkCmdPipelineBarrier2");
+    out->vkCmdWriteTimestamp2 =
+        (PFN_vkCmdWriteTimestamp2)vk->vkGetDeviceProcAddr(device, "vkCmdWriteTimestamp2");
+    out->vkQueueSubmit2 = (PFN_vkQueueSubmit2)vk->vkGetDeviceProcAddr(device, "vkQueueSubmit2");
+    out->vkCmdCopyBuffer2 =
+        (PFN_vkCmdCopyBuffer2)vk->vkGetDeviceProcAddr(device, "vkCmdCopyBuffer2");
+    out->vkCmdCopyImage2 = (PFN_vkCmdCopyImage2)vk->vkGetDeviceProcAddr(device, "vkCmdCopyImage2");
+    out->vkCmdCopyBufferToImage2 =
+        (PFN_vkCmdCopyBufferToImage2)vk->vkGetDeviceProcAddr(device, "vkCmdCopyBufferToImage2");
+    out->vkCmdCopyImageToBuffer2 =
+        (PFN_vkCmdCopyImageToBuffer2)vk->vkGetDeviceProcAddr(device, "vkCmdCopyImageToBuffer2");
+    out->vkCmdBlitImage2 = (PFN_vkCmdBlitImage2)vk->vkGetDeviceProcAddr(device, "vkCmdBlitImage2");
+    out->vkCmdResolveImage2 =
+        (PFN_vkCmdResolveImage2)vk->vkGetDeviceProcAddr(device, "vkCmdResolveImage2");
+    out->vkCmdBeginRendering =
+        (PFN_vkCmdBeginRendering)vk->vkGetDeviceProcAddr(device, "vkCmdBeginRendering");
+    out->vkCmdEndRendering =
+        (PFN_vkCmdEndRendering)vk->vkGetDeviceProcAddr(device, "vkCmdEndRendering");
+    out->vkCmdSetCullMode =
+        (PFN_vkCmdSetCullMode)vk->vkGetDeviceProcAddr(device, "vkCmdSetCullMode");
+    out->vkCmdSetFrontFace =
+        (PFN_vkCmdSetFrontFace)vk->vkGetDeviceProcAddr(device, "vkCmdSetFrontFace");
+    out->vkCmdSetPrimitiveTopology =
+        (PFN_vkCmdSetPrimitiveTopology)vk->vkGetDeviceProcAddr(device, "vkCmdSetPrimitiveTopology");
+    out->vkCmdSetViewportWithCount =
+        (PFN_vkCmdSetViewportWithCount)vk->vkGetDeviceProcAddr(device, "vkCmdSetViewportWithCount");
+    out->vkCmdSetScissorWithCount =
+        (PFN_vkCmdSetScissorWithCount)vk->vkGetDeviceProcAddr(device, "vkCmdSetScissorWithCount");
+    out->vkCmdBindVertexBuffers2 =
+        (PFN_vkCmdBindVertexBuffers2)vk->vkGetDeviceProcAddr(device, "vkCmdBindVertexBuffers2");
+    out->vkCmdSetDepthTestEnable =
+        (PFN_vkCmdSetDepthTestEnable)vk->vkGetDeviceProcAddr(device, "vkCmdSetDepthTestEnable");
+    out->vkCmdSetDepthWriteEnable =
+        (PFN_vkCmdSetDepthWriteEnable)vk->vkGetDeviceProcAddr(device, "vkCmdSetDepthWriteEnable");
+    out->vkCmdSetDepthCompareOp =
+        (PFN_vkCmdSetDepthCompareOp)vk->vkGetDeviceProcAddr(device, "vkCmdSetDepthCompareOp");
+    out->vkCmdSetDepthBoundsTestEnable = (PFN_vkCmdSetDepthBoundsTestEnable)vk->vkGetDeviceProcAddr(
+        device, "vkCmdSetDepthBoundsTestEnable");
+    out->vkCmdSetStencilTestEnable =
+        (PFN_vkCmdSetStencilTestEnable)vk->vkGetDeviceProcAddr(device, "vkCmdSetStencilTestEnable");
+    out->vkCmdSetStencilOp =
+        (PFN_vkCmdSetStencilOp)vk->vkGetDeviceProcAddr(device, "vkCmdSetStencilOp");
+    out->vkCmdSetRasterizerDiscardEnable =
+        (PFN_vkCmdSetRasterizerDiscardEnable)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetRasterizerDiscardEnable");
+    out->vkCmdSetDepthBiasEnable =
+        (PFN_vkCmdSetDepthBiasEnable)vk->vkGetDeviceProcAddr(device, "vkCmdSetDepthBiasEnable");
+    out->vkCmdSetPrimitiveRestartEnable =
+        (PFN_vkCmdSetPrimitiveRestartEnable)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetPrimitiveRestartEnable");
+    out->vkGetDeviceBufferMemoryRequirements =
+        (PFN_vkGetDeviceBufferMemoryRequirements)vk->vkGetDeviceProcAddr(
+            device, "vkGetDeviceBufferMemoryRequirements");
+    out->vkGetDeviceImageMemoryRequirements =
+        (PFN_vkGetDeviceImageMemoryRequirements)vk->vkGetDeviceProcAddr(
+            device, "vkGetDeviceImageMemoryRequirements");
+    out->vkGetDeviceImageSparseMemoryRequirements =
+        (PFN_vkGetDeviceImageSparseMemoryRequirements)vk->vkGetDeviceProcAddr(
+            device, "vkGetDeviceImageSparseMemoryRequirements");
+#endif
 #ifdef VK_KHR_surface
     out->vkGetPhysicalDeviceSurfaceSupportKHR =
         (PFN_vkGetPhysicalDeviceSurfaceSupportKHR)vk->vkGetDeviceProcAddr(
@@ -4196,6 +5044,11 @@ void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, Vulka
         (PFN_vkGetPipelineExecutableInternalRepresentationsKHR)vk->vkGetDeviceProcAddr(
             device, "vkGetPipelineExecutableInternalRepresentationsKHR");
 #endif
+#ifdef VK_KHR_map_memory2
+    out->vkMapMemory2KHR = (PFN_vkMapMemory2KHR)vk->vkGetDeviceProcAddr(device, "vkMapMemory2KHR");
+    out->vkUnmapMemory2KHR =
+        (PFN_vkUnmapMemory2KHR)vk->vkGetDeviceProcAddr(device, "vkUnmapMemory2KHR");
+#endif
 #ifdef VK_KHR_video_encode_queue
     out->vkCmdEncodeVideoKHR =
         (PFN_vkCmdEncodeVideoKHR)vk->vkGetDeviceProcAddr(device, "vkCmdEncodeVideoKHR");
@@ -4232,6 +5085,10 @@ void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, Vulka
     out->vkCmdResolveImage2KHR =
         (PFN_vkCmdResolveImage2KHR)vk->vkGetDeviceProcAddr(device, "vkCmdResolveImage2KHR");
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+    out->vkCmdTraceRaysIndirect2KHR = (PFN_vkCmdTraceRaysIndirect2KHR)vk->vkGetDeviceProcAddr(
+        device, "vkCmdTraceRaysIndirect2KHR");
+#endif
 #ifdef VK_KHR_maintenance4
     out->vkGetDeviceBufferMemoryRequirementsKHR =
         (PFN_vkGetDeviceBufferMemoryRequirementsKHR)vk->vkGetDeviceProcAddr(
@@ -4252,6 +5109,9 @@ void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, Vulka
     out->vkQueueSignalReleaseImageANDROID =
         (PFN_vkQueueSignalReleaseImageANDROID)vk->vkGetDeviceProcAddr(
             device, "vkQueueSignalReleaseImageANDROID");
+    out->vkGetSwapchainGrallocUsage2ANDROID =
+        (PFN_vkGetSwapchainGrallocUsage2ANDROID)vk->vkGetDeviceProcAddr(
+            device, "vkGetSwapchainGrallocUsage2ANDROID");
 #endif
 #ifdef VK_EXT_debug_marker
     out->vkDebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)vk->vkGetDeviceProcAddr(
@@ -4367,6 +5227,12 @@ void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, Vulka
 #ifdef VK_EXT_discard_rectangles
     out->vkCmdSetDiscardRectangleEXT = (PFN_vkCmdSetDiscardRectangleEXT)vk->vkGetDeviceProcAddr(
         device, "vkCmdSetDiscardRectangleEXT");
+    out->vkCmdSetDiscardRectangleEnableEXT =
+        (PFN_vkCmdSetDiscardRectangleEnableEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetDiscardRectangleEnableEXT");
+    out->vkCmdSetDiscardRectangleModeEXT =
+        (PFN_vkCmdSetDiscardRectangleModeEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetDiscardRectangleModeEXT");
 #endif
 #ifdef VK_EXT_hdr_metadata
     out->vkSetHdrMetadataEXT =
@@ -4495,6 +5361,9 @@ void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, Vulka
             device, "vkCmdDrawMeshTasksIndirectCountNV");
 #endif
 #ifdef VK_NV_scissor_exclusive
+    out->vkCmdSetExclusiveScissorEnableNV =
+        (PFN_vkCmdSetExclusiveScissorEnableNV)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetExclusiveScissorEnableNV");
     out->vkCmdSetExclusiveScissorNV = (PFN_vkCmdSetExclusiveScissorNV)vk->vkGetDeviceProcAddr(
         device, "vkCmdSetExclusiveScissorNV");
 #endif
@@ -4606,6 +5475,10 @@ void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, Vulka
     out->vkCmdSetStencilOpEXT =
         (PFN_vkCmdSetStencilOpEXT)vk->vkGetDeviceProcAddr(device, "vkCmdSetStencilOpEXT");
 #endif
+#ifdef VK_EXT_swapchain_maintenance1
+    out->vkReleaseSwapchainImagesEXT = (PFN_vkReleaseSwapchainImagesEXT)vk->vkGetDeviceProcAddr(
+        device, "vkReleaseSwapchainImagesEXT");
+#endif
 #ifdef VK_NV_device_generated_commands
     out->vkGetGeneratedCommandsMemoryRequirementsNV =
         (PFN_vkGetGeneratedCommandsMemoryRequirementsNV)vk->vkGetDeviceProcAddr(
@@ -4642,11 +5515,57 @@ void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, Vulka
     out->vkGetPrivateDataEXT =
         (PFN_vkGetPrivateDataEXT)vk->vkGetDeviceProcAddr(device, "vkGetPrivateDataEXT");
 #endif
+#ifdef VK_EXT_metal_objects
+    out->vkExportMetalObjectsEXT =
+        (PFN_vkExportMetalObjectsEXT)vk->vkGetDeviceProcAddr(device, "vkExportMetalObjectsEXT");
+#endif
+#ifdef VK_EXT_descriptor_buffer
+    out->vkGetDescriptorSetLayoutSizeEXT =
+        (PFN_vkGetDescriptorSetLayoutSizeEXT)vk->vkGetDeviceProcAddr(
+            device, "vkGetDescriptorSetLayoutSizeEXT");
+    out->vkGetDescriptorSetLayoutBindingOffsetEXT =
+        (PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)vk->vkGetDeviceProcAddr(
+            device, "vkGetDescriptorSetLayoutBindingOffsetEXT");
+    out->vkGetDescriptorEXT =
+        (PFN_vkGetDescriptorEXT)vk->vkGetDeviceProcAddr(device, "vkGetDescriptorEXT");
+    out->vkCmdBindDescriptorBuffersEXT = (PFN_vkCmdBindDescriptorBuffersEXT)vk->vkGetDeviceProcAddr(
+        device, "vkCmdBindDescriptorBuffersEXT");
+    out->vkCmdSetDescriptorBufferOffsetsEXT =
+        (PFN_vkCmdSetDescriptorBufferOffsetsEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetDescriptorBufferOffsetsEXT");
+    out->vkCmdBindDescriptorBufferEmbeddedSamplersEXT =
+        (PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT");
+    out->vkGetBufferOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)vk->vkGetDeviceProcAddr(
+            device, "vkGetBufferOpaqueCaptureDescriptorDataEXT");
+    out->vkGetImageOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)vk->vkGetDeviceProcAddr(
+            device, "vkGetImageOpaqueCaptureDescriptorDataEXT");
+    out->vkGetImageViewOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)vk->vkGetDeviceProcAddr(
+            device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT");
+    out->vkGetSamplerOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)vk->vkGetDeviceProcAddr(
+            device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT");
+    out->vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT =
+        (PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)vk->vkGetDeviceProcAddr(
+            device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT");
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
     out->vkCmdSetFragmentShadingRateEnumNV =
         (PFN_vkCmdSetFragmentShadingRateEnumNV)vk->vkGetDeviceProcAddr(
             device, "vkCmdSetFragmentShadingRateEnumNV");
 #endif
+#ifdef VK_EXT_image_compression_control
+    out->vkGetImageSubresourceLayout2EXT =
+        (PFN_vkGetImageSubresourceLayout2EXT)vk->vkGetDeviceProcAddr(
+            device, "vkGetImageSubresourceLayout2EXT");
+#endif
+#ifdef VK_EXT_device_fault
+    out->vkGetDeviceFaultInfoEXT =
+        (PFN_vkGetDeviceFaultInfoEXT)vk->vkGetDeviceProcAddr(device, "vkGetDeviceFaultInfoEXT");
+#endif
 #ifdef VK_NV_acquire_winrt_display
     out->vkAcquireWinrtDisplayNV =
         (PFN_vkAcquireWinrtDisplayNV)vk->vkGetDeviceProcAddr(device, "vkAcquireWinrtDisplayNV");
@@ -4710,6 +5629,10 @@ void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, Vulka
     out->vkGetMemoryRemoteAddressNV = (PFN_vkGetMemoryRemoteAddressNV)vk->vkGetDeviceProcAddr(
         device, "vkGetMemoryRemoteAddressNV");
 #endif
+#ifdef VK_EXT_pipeline_properties
+    out->vkGetPipelinePropertiesEXT = (PFN_vkGetPipelinePropertiesEXT)vk->vkGetDeviceProcAddr(
+        device, "vkGetPipelinePropertiesEXT");
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
     out->vkCmdSetPatchControlPointsEXT = (PFN_vkCmdSetPatchControlPointsEXT)vk->vkGetDeviceProcAddr(
         device, "vkCmdSetPatchControlPointsEXT");
@@ -4788,6 +5711,9 @@ void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, Vulka
         (PFN_vkQueueFlushCommandsFromAuxMemoryGOOGLE)vk->vkGetDeviceProcAddr(
             device, "vkQueueFlushCommandsFromAuxMemoryGOOGLE");
     out->vkGetBlobGOOGLE = (PFN_vkGetBlobGOOGLE)vk->vkGetDeviceProcAddr(device, "vkGetBlobGOOGLE");
+    out->vkUpdateDescriptorSetWithTemplateSized2GOOGLE =
+        (PFN_vkUpdateDescriptorSetWithTemplateSized2GOOGLE)vk->vkGetDeviceProcAddr(
+            device, "vkUpdateDescriptorSetWithTemplateSized2GOOGLE");
 #endif
 #ifdef VK_EXT_multi_draw
     out->vkCmdDrawMultiEXT =
@@ -4795,10 +5721,199 @@ void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, Vulka
     out->vkCmdDrawMultiIndexedEXT =
         (PFN_vkCmdDrawMultiIndexedEXT)vk->vkGetDeviceProcAddr(device, "vkCmdDrawMultiIndexedEXT");
 #endif
+#ifdef VK_EXT_opacity_micromap
+    out->vkCreateMicromapEXT =
+        (PFN_vkCreateMicromapEXT)vk->vkGetDeviceProcAddr(device, "vkCreateMicromapEXT");
+    out->vkDestroyMicromapEXT =
+        (PFN_vkDestroyMicromapEXT)vk->vkGetDeviceProcAddr(device, "vkDestroyMicromapEXT");
+    out->vkCmdBuildMicromapsEXT =
+        (PFN_vkCmdBuildMicromapsEXT)vk->vkGetDeviceProcAddr(device, "vkCmdBuildMicromapsEXT");
+    out->vkBuildMicromapsEXT =
+        (PFN_vkBuildMicromapsEXT)vk->vkGetDeviceProcAddr(device, "vkBuildMicromapsEXT");
+    out->vkCopyMicromapEXT =
+        (PFN_vkCopyMicromapEXT)vk->vkGetDeviceProcAddr(device, "vkCopyMicromapEXT");
+    out->vkCopyMicromapToMemoryEXT =
+        (PFN_vkCopyMicromapToMemoryEXT)vk->vkGetDeviceProcAddr(device, "vkCopyMicromapToMemoryEXT");
+    out->vkCopyMemoryToMicromapEXT =
+        (PFN_vkCopyMemoryToMicromapEXT)vk->vkGetDeviceProcAddr(device, "vkCopyMemoryToMicromapEXT");
+    out->vkWriteMicromapsPropertiesEXT = (PFN_vkWriteMicromapsPropertiesEXT)vk->vkGetDeviceProcAddr(
+        device, "vkWriteMicromapsPropertiesEXT");
+    out->vkCmdCopyMicromapEXT =
+        (PFN_vkCmdCopyMicromapEXT)vk->vkGetDeviceProcAddr(device, "vkCmdCopyMicromapEXT");
+    out->vkCmdCopyMicromapToMemoryEXT = (PFN_vkCmdCopyMicromapToMemoryEXT)vk->vkGetDeviceProcAddr(
+        device, "vkCmdCopyMicromapToMemoryEXT");
+    out->vkCmdCopyMemoryToMicromapEXT = (PFN_vkCmdCopyMemoryToMicromapEXT)vk->vkGetDeviceProcAddr(
+        device, "vkCmdCopyMemoryToMicromapEXT");
+    out->vkCmdWriteMicromapsPropertiesEXT =
+        (PFN_vkCmdWriteMicromapsPropertiesEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdWriteMicromapsPropertiesEXT");
+    out->vkGetDeviceMicromapCompatibilityEXT =
+        (PFN_vkGetDeviceMicromapCompatibilityEXT)vk->vkGetDeviceProcAddr(
+            device, "vkGetDeviceMicromapCompatibilityEXT");
+    out->vkGetMicromapBuildSizesEXT = (PFN_vkGetMicromapBuildSizesEXT)vk->vkGetDeviceProcAddr(
+        device, "vkGetMicromapBuildSizesEXT");
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+    out->vkCmdDrawClusterHUAWEI =
+        (PFN_vkCmdDrawClusterHUAWEI)vk->vkGetDeviceProcAddr(device, "vkCmdDrawClusterHUAWEI");
+    out->vkCmdDrawClusterIndirectHUAWEI =
+        (PFN_vkCmdDrawClusterIndirectHUAWEI)vk->vkGetDeviceProcAddr(
+            device, "vkCmdDrawClusterIndirectHUAWEI");
+#endif
 #ifdef VK_EXT_pageable_device_local_memory
     out->vkSetDeviceMemoryPriorityEXT = (PFN_vkSetDeviceMemoryPriorityEXT)vk->vkGetDeviceProcAddr(
         device, "vkSetDeviceMemoryPriorityEXT");
 #endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+    out->vkGetDescriptorSetLayoutHostMappingInfoVALVE =
+        (PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)vk->vkGetDeviceProcAddr(
+            device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE");
+    out->vkGetDescriptorSetHostMappingVALVE =
+        (PFN_vkGetDescriptorSetHostMappingVALVE)vk->vkGetDeviceProcAddr(
+            device, "vkGetDescriptorSetHostMappingVALVE");
+#endif
+#ifdef VK_NV_copy_memory_indirect
+    out->vkCmdCopyMemoryIndirectNV =
+        (PFN_vkCmdCopyMemoryIndirectNV)vk->vkGetDeviceProcAddr(device, "vkCmdCopyMemoryIndirectNV");
+    out->vkCmdCopyMemoryToImageIndirectNV =
+        (PFN_vkCmdCopyMemoryToImageIndirectNV)vk->vkGetDeviceProcAddr(
+            device, "vkCmdCopyMemoryToImageIndirectNV");
+#endif
+#ifdef VK_NV_memory_decompression
+    out->vkCmdDecompressMemoryNV =
+        (PFN_vkCmdDecompressMemoryNV)vk->vkGetDeviceProcAddr(device, "vkCmdDecompressMemoryNV");
+    out->vkCmdDecompressMemoryIndirectCountNV =
+        (PFN_vkCmdDecompressMemoryIndirectCountNV)vk->vkGetDeviceProcAddr(
+            device, "vkCmdDecompressMemoryIndirectCountNV");
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+    out->vkCmdSetTessellationDomainOriginEXT =
+        (PFN_vkCmdSetTessellationDomainOriginEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetTessellationDomainOriginEXT");
+    out->vkCmdSetDepthClampEnableEXT = (PFN_vkCmdSetDepthClampEnableEXT)vk->vkGetDeviceProcAddr(
+        device, "vkCmdSetDepthClampEnableEXT");
+    out->vkCmdSetPolygonModeEXT =
+        (PFN_vkCmdSetPolygonModeEXT)vk->vkGetDeviceProcAddr(device, "vkCmdSetPolygonModeEXT");
+    out->vkCmdSetRasterizationSamplesEXT =
+        (PFN_vkCmdSetRasterizationSamplesEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetRasterizationSamplesEXT");
+    out->vkCmdSetSampleMaskEXT =
+        (PFN_vkCmdSetSampleMaskEXT)vk->vkGetDeviceProcAddr(device, "vkCmdSetSampleMaskEXT");
+    out->vkCmdSetAlphaToCoverageEnableEXT =
+        (PFN_vkCmdSetAlphaToCoverageEnableEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetAlphaToCoverageEnableEXT");
+    out->vkCmdSetAlphaToOneEnableEXT = (PFN_vkCmdSetAlphaToOneEnableEXT)vk->vkGetDeviceProcAddr(
+        device, "vkCmdSetAlphaToOneEnableEXT");
+    out->vkCmdSetLogicOpEnableEXT =
+        (PFN_vkCmdSetLogicOpEnableEXT)vk->vkGetDeviceProcAddr(device, "vkCmdSetLogicOpEnableEXT");
+    out->vkCmdSetColorBlendEnableEXT = (PFN_vkCmdSetColorBlendEnableEXT)vk->vkGetDeviceProcAddr(
+        device, "vkCmdSetColorBlendEnableEXT");
+    out->vkCmdSetColorBlendEquationEXT = (PFN_vkCmdSetColorBlendEquationEXT)vk->vkGetDeviceProcAddr(
+        device, "vkCmdSetColorBlendEquationEXT");
+    out->vkCmdSetColorWriteMaskEXT =
+        (PFN_vkCmdSetColorWriteMaskEXT)vk->vkGetDeviceProcAddr(device, "vkCmdSetColorWriteMaskEXT");
+    out->vkCmdSetRasterizationStreamEXT =
+        (PFN_vkCmdSetRasterizationStreamEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetRasterizationStreamEXT");
+    out->vkCmdSetConservativeRasterizationModeEXT =
+        (PFN_vkCmdSetConservativeRasterizationModeEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetConservativeRasterizationModeEXT");
+    out->vkCmdSetExtraPrimitiveOverestimationSizeEXT =
+        (PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT");
+    out->vkCmdSetDepthClipEnableEXT = (PFN_vkCmdSetDepthClipEnableEXT)vk->vkGetDeviceProcAddr(
+        device, "vkCmdSetDepthClipEnableEXT");
+    out->vkCmdSetSampleLocationsEnableEXT =
+        (PFN_vkCmdSetSampleLocationsEnableEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetSampleLocationsEnableEXT");
+    out->vkCmdSetColorBlendAdvancedEXT = (PFN_vkCmdSetColorBlendAdvancedEXT)vk->vkGetDeviceProcAddr(
+        device, "vkCmdSetColorBlendAdvancedEXT");
+    out->vkCmdSetProvokingVertexModeEXT =
+        (PFN_vkCmdSetProvokingVertexModeEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetProvokingVertexModeEXT");
+    out->vkCmdSetLineRasterizationModeEXT =
+        (PFN_vkCmdSetLineRasterizationModeEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetLineRasterizationModeEXT");
+    out->vkCmdSetLineStippleEnableEXT = (PFN_vkCmdSetLineStippleEnableEXT)vk->vkGetDeviceProcAddr(
+        device, "vkCmdSetLineStippleEnableEXT");
+    out->vkCmdSetDepthClipNegativeOneToOneEXT =
+        (PFN_vkCmdSetDepthClipNegativeOneToOneEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetDepthClipNegativeOneToOneEXT");
+    out->vkCmdSetViewportWScalingEnableNV =
+        (PFN_vkCmdSetViewportWScalingEnableNV)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetViewportWScalingEnableNV");
+    out->vkCmdSetViewportSwizzleNV =
+        (PFN_vkCmdSetViewportSwizzleNV)vk->vkGetDeviceProcAddr(device, "vkCmdSetViewportSwizzleNV");
+    out->vkCmdSetCoverageToColorEnableNV =
+        (PFN_vkCmdSetCoverageToColorEnableNV)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetCoverageToColorEnableNV");
+    out->vkCmdSetCoverageToColorLocationNV =
+        (PFN_vkCmdSetCoverageToColorLocationNV)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetCoverageToColorLocationNV");
+    out->vkCmdSetCoverageModulationModeNV =
+        (PFN_vkCmdSetCoverageModulationModeNV)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetCoverageModulationModeNV");
+    out->vkCmdSetCoverageModulationTableEnableNV =
+        (PFN_vkCmdSetCoverageModulationTableEnableNV)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetCoverageModulationTableEnableNV");
+    out->vkCmdSetCoverageModulationTableNV =
+        (PFN_vkCmdSetCoverageModulationTableNV)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetCoverageModulationTableNV");
+    out->vkCmdSetShadingRateImageEnableNV =
+        (PFN_vkCmdSetShadingRateImageEnableNV)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetShadingRateImageEnableNV");
+    out->vkCmdSetRepresentativeFragmentTestEnableNV =
+        (PFN_vkCmdSetRepresentativeFragmentTestEnableNV)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetRepresentativeFragmentTestEnableNV");
+    out->vkCmdSetCoverageReductionModeNV =
+        (PFN_vkCmdSetCoverageReductionModeNV)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetCoverageReductionModeNV");
+#endif
+#ifdef VK_EXT_shader_module_identifier
+    out->vkGetShaderModuleIdentifierEXT =
+        (PFN_vkGetShaderModuleIdentifierEXT)vk->vkGetDeviceProcAddr(
+            device, "vkGetShaderModuleIdentifierEXT");
+    out->vkGetShaderModuleCreateInfoIdentifierEXT =
+        (PFN_vkGetShaderModuleCreateInfoIdentifierEXT)vk->vkGetDeviceProcAddr(
+            device, "vkGetShaderModuleCreateInfoIdentifierEXT");
+#endif
+#ifdef VK_NV_optical_flow
+    out->vkGetPhysicalDeviceOpticalFlowImageFormatsNV =
+        (PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)vk->vkGetDeviceProcAddr(
+            device, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV");
+    out->vkCreateOpticalFlowSessionNV = (PFN_vkCreateOpticalFlowSessionNV)vk->vkGetDeviceProcAddr(
+        device, "vkCreateOpticalFlowSessionNV");
+    out->vkDestroyOpticalFlowSessionNV = (PFN_vkDestroyOpticalFlowSessionNV)vk->vkGetDeviceProcAddr(
+        device, "vkDestroyOpticalFlowSessionNV");
+    out->vkBindOpticalFlowSessionImageNV =
+        (PFN_vkBindOpticalFlowSessionImageNV)vk->vkGetDeviceProcAddr(
+            device, "vkBindOpticalFlowSessionImageNV");
+    out->vkCmdOpticalFlowExecuteNV =
+        (PFN_vkCmdOpticalFlowExecuteNV)vk->vkGetDeviceProcAddr(device, "vkCmdOpticalFlowExecuteNV");
+#endif
+#ifdef VK_EXT_shader_object
+    out->vkCreateShadersEXT =
+        (PFN_vkCreateShadersEXT)vk->vkGetDeviceProcAddr(device, "vkCreateShadersEXT");
+    out->vkDestroyShaderEXT =
+        (PFN_vkDestroyShaderEXT)vk->vkGetDeviceProcAddr(device, "vkDestroyShaderEXT");
+    out->vkGetShaderBinaryDataEXT =
+        (PFN_vkGetShaderBinaryDataEXT)vk->vkGetDeviceProcAddr(device, "vkGetShaderBinaryDataEXT");
+    out->vkCmdBindShadersEXT =
+        (PFN_vkCmdBindShadersEXT)vk->vkGetDeviceProcAddr(device, "vkCmdBindShadersEXT");
+#endif
+#ifdef VK_QCOM_tile_properties
+    out->vkGetFramebufferTilePropertiesQCOM =
+        (PFN_vkGetFramebufferTilePropertiesQCOM)vk->vkGetDeviceProcAddr(
+            device, "vkGetFramebufferTilePropertiesQCOM");
+    out->vkGetDynamicRenderingTilePropertiesQCOM =
+        (PFN_vkGetDynamicRenderingTilePropertiesQCOM)vk->vkGetDeviceProcAddr(
+            device, "vkGetDynamicRenderingTilePropertiesQCOM");
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+    out->vkCmdSetAttachmentFeedbackLoopEnableEXT =
+        (PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdSetAttachmentFeedbackLoopEnableEXT");
+#endif
 #ifdef VK_KHR_acceleration_structure
     out->vkCreateAccelerationStructureKHR =
         (PFN_vkCreateAccelerationStructureKHR)vk->vkGetDeviceProcAddr(
@@ -4867,6 +5982,15 @@ void init_vulkan_dispatch_from_device(VulkanDispatch* vk, VkDevice device, Vulka
         (PFN_vkCmdSetRayTracingPipelineStackSizeKHR)vk->vkGetDeviceProcAddr(
             device, "vkCmdSetRayTracingPipelineStackSizeKHR");
 #endif
+#ifdef VK_EXT_mesh_shader
+    out->vkCmdDrawMeshTasksEXT =
+        (PFN_vkCmdDrawMeshTasksEXT)vk->vkGetDeviceProcAddr(device, "vkCmdDrawMeshTasksEXT");
+    out->vkCmdDrawMeshTasksIndirectEXT = (PFN_vkCmdDrawMeshTasksIndirectEXT)vk->vkGetDeviceProcAddr(
+        device, "vkCmdDrawMeshTasksIndirectEXT");
+    out->vkCmdDrawMeshTasksIndirectCountEXT =
+        (PFN_vkCmdDrawMeshTasksIndirectCountEXT)vk->vkGetDeviceProcAddr(
+            device, "vkCmdDrawMeshTasksIndirectCountEXT");
+#endif
 }
 
 bool vulkan_dispatch_check_instance_VK_VERSION_1_0(const VulkanDispatch* vk)
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_dispatch.h b/stream-servers/vulkan/cereal/common/goldfish_vk_dispatch.h
index d80f100d..99ca96d4 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_dispatch.h
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_dispatch.h
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_dispatch
 //
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (header) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -252,6 +252,45 @@ struct VulkanDispatch {
     PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress;
     PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress;
 #endif
+#ifdef VK_VERSION_1_3
+    PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties;
+    PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot;
+    PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot;
+    PFN_vkSetPrivateData vkSetPrivateData;
+    PFN_vkGetPrivateData vkGetPrivateData;
+    PFN_vkCmdSetEvent2 vkCmdSetEvent2;
+    PFN_vkCmdResetEvent2 vkCmdResetEvent2;
+    PFN_vkCmdWaitEvents2 vkCmdWaitEvents2;
+    PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2;
+    PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2;
+    PFN_vkQueueSubmit2 vkQueueSubmit2;
+    PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2;
+    PFN_vkCmdCopyImage2 vkCmdCopyImage2;
+    PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2;
+    PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2;
+    PFN_vkCmdBlitImage2 vkCmdBlitImage2;
+    PFN_vkCmdResolveImage2 vkCmdResolveImage2;
+    PFN_vkCmdBeginRendering vkCmdBeginRendering;
+    PFN_vkCmdEndRendering vkCmdEndRendering;
+    PFN_vkCmdSetCullMode vkCmdSetCullMode;
+    PFN_vkCmdSetFrontFace vkCmdSetFrontFace;
+    PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology;
+    PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount;
+    PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount;
+    PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2;
+    PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable;
+    PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable;
+    PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp;
+    PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable;
+    PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable;
+    PFN_vkCmdSetStencilOp vkCmdSetStencilOp;
+    PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable;
+    PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable;
+    PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable;
+    PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements;
+    PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements;
+    PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements;
+#endif
 #ifdef VK_KHR_surface
     PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR;
     PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR;
@@ -322,6 +361,8 @@ struct VulkanDispatch {
 #ifdef VK_KHR_video_decode_queue
     PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR;
 #endif
+#ifdef VK_KHR_video_decode_h264
+#endif
 #ifdef VK_KHR_dynamic_rendering
     PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR;
     PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR;
@@ -480,6 +521,10 @@ struct VulkanDispatch {
 #endif
 #ifdef VK_KHR_shader_clock
 #endif
+#ifdef VK_KHR_video_decode_h265
+#endif
+#ifdef VK_KHR_global_priority
+#endif
 #ifdef VK_KHR_driver_properties
 #endif
 #ifdef VK_KHR_shader_float_controls
@@ -530,6 +575,10 @@ struct VulkanDispatch {
     PFN_vkGetPipelineExecutableInternalRepresentationsKHR
         vkGetPipelineExecutableInternalRepresentationsKHR;
 #endif
+#ifdef VK_KHR_map_memory2
+    PFN_vkMapMemory2KHR vkMapMemory2KHR;
+    PFN_vkUnmapMemory2KHR vkUnmapMemory2KHR;
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -551,6 +600,8 @@ struct VulkanDispatch {
     PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD;
     PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV;
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
@@ -567,15 +618,23 @@ struct VulkanDispatch {
 #endif
 #ifdef VK_KHR_format_feature_flags2
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+    PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR;
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
     PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR;
     PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR;
     PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR;
 #endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+#endif
 #ifdef VK_ANDROID_native_buffer
     PFN_vkGetSwapchainGrallocUsageANDROID vkGetSwapchainGrallocUsageANDROID;
     PFN_vkAcquireImageANDROID vkAcquireImageANDROID;
     PFN_vkQueueSignalReleaseImageANDROID vkQueueSignalReleaseImageANDROID;
+    PFN_vkGetSwapchainGrallocUsage2ANDROID vkGetSwapchainGrallocUsage2ANDROID;
 #endif
 #ifdef VK_EXT_debug_report
     PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT;
@@ -638,8 +697,6 @@ struct VulkanDispatch {
 #endif
 #ifdef VK_EXT_video_encode_h265
 #endif
-#ifdef VK_EXT_video_decode_h264
-#endif
 #ifdef VK_AMD_texture_gather_bias_lod
 #endif
 #ifdef VK_AMD_shader_info
@@ -678,6 +735,8 @@ struct VulkanDispatch {
 #endif
 #ifdef VK_EXT_astc_decode_mode
 #endif
+#ifdef VK_EXT_pipeline_robustness
+#endif
 #ifdef VK_EXT_conditional_rendering
     PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT;
     PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT;
@@ -717,6 +776,8 @@ struct VulkanDispatch {
 #endif
 #ifdef VK_EXT_discard_rectangles
     PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT;
+    PFN_vkCmdSetDiscardRectangleEnableEXT vkCmdSetDiscardRectangleEnableEXT;
+    PFN_vkCmdSetDiscardRectangleModeEXT vkCmdSetDiscardRectangleModeEXT;
 #endif
 #ifdef VK_EXT_conservative_rasterization
 #endif
@@ -733,14 +794,6 @@ struct VulkanDispatch {
 #ifdef VK_MVK_macos_surface
     PFN_vkCreateMacOSSurfaceMVK vkCreateMacOSSurfaceMVK;
 #endif
-#ifdef VK_MVK_moltenvk
-    PFN_vkGetMTLDeviceMVK vkGetMTLDeviceMVK;
-    PFN_vkSetMTLTextureMVK vkSetMTLTextureMVK;
-    PFN_vkGetMTLTextureMVK vkGetMTLTextureMVK;
-    PFN_vkGetMTLBufferMVK vkGetMTLBufferMVK;
-    PFN_vkUseIOSurfaceMVK vkUseIOSurfaceMVK;
-    PFN_vkGetIOSurfaceMVK vkGetIOSurfaceMVK;
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -847,8 +900,6 @@ struct VulkanDispatch {
 #endif
 #ifdef VK_AMD_shader_core_properties
 #endif
-#ifdef VK_EXT_video_decode_h265
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 #endif
 #ifdef VK_EXT_vertex_attribute_divisor
@@ -871,6 +922,7 @@ struct VulkanDispatch {
 #ifdef VK_NV_shader_image_footprint
 #endif
 #ifdef VK_NV_scissor_exclusive
+    PFN_vkCmdSetExclusiveScissorEnableNV vkCmdSetExclusiveScissorEnableNV;
     PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV;
 #endif
 #ifdef VK_NV_device_diagnostic_checkpoints
@@ -982,6 +1034,11 @@ struct VulkanDispatch {
 #endif
 #ifdef VK_EXT_shader_atomic_float2
 #endif
+#ifdef VK_EXT_surface_maintenance1
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+    PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT;
+#endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -1010,6 +1067,8 @@ struct VulkanDispatch {
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+#endif
 #ifdef VK_EXT_private_data
     PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT;
     PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT;
@@ -1022,6 +1081,29 @@ struct VulkanDispatch {
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+#endif
+#ifdef VK_EXT_metal_objects
+    PFN_vkExportMetalObjectsEXT vkExportMetalObjectsEXT;
+#endif
+#ifdef VK_EXT_descriptor_buffer
+    PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT;
+    PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT;
+    PFN_vkGetDescriptorEXT vkGetDescriptorEXT;
+    PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT;
+    PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT;
+    PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT;
+    PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT;
+    PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT;
+    PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT;
+    PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT;
+    PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT
+        vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT;
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
     PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV;
 #endif
@@ -1035,8 +1117,18 @@ struct VulkanDispatch {
 #endif
 #ifdef VK_EXT_image_robustness
 #endif
+#ifdef VK_EXT_image_compression_control
+    PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT;
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+#endif
 #ifdef VK_EXT_4444_formats
 #endif
+#ifdef VK_EXT_device_fault
+    PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT;
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 #endif
 #ifdef VK_NV_acquire_winrt_display
@@ -1055,6 +1147,10 @@ struct VulkanDispatch {
 #endif
 #ifdef VK_EXT_physical_device_drm
 #endif
+#ifdef VK_EXT_device_address_binding_report
+#endif
+#ifdef VK_EXT_depth_clip_control
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 #endif
 #ifdef VK_FUCHSIA_external_memory
@@ -1083,6 +1179,11 @@ struct VulkanDispatch {
 #ifdef VK_NV_external_memory_rdma
     PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV;
 #endif
+#ifdef VK_EXT_pipeline_properties
+    PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT;
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
     PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT;
     PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT;
@@ -1098,6 +1199,8 @@ struct VulkanDispatch {
 #ifdef VK_EXT_color_write_enable
     PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT;
 #endif
+#ifdef VK_EXT_primitives_generated_query
+#endif
 #ifdef VK_GOOGLE_gfxstream
     PFN_vkMapMemoryIntoAddressSpaceGOOGLE vkMapMemoryIntoAddressSpaceGOOGLE;
     PFN_vkUpdateDescriptorSetWithTemplateSizedGOOGLE vkUpdateDescriptorSetWithTemplateSizedGOOGLE;
@@ -1121,20 +1224,160 @@ struct VulkanDispatch {
     PFN_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE vkQueueSignalReleaseImageANDROIDAsyncGOOGLE;
     PFN_vkQueueFlushCommandsFromAuxMemoryGOOGLE vkQueueFlushCommandsFromAuxMemoryGOOGLE;
     PFN_vkGetBlobGOOGLE vkGetBlobGOOGLE;
+    PFN_vkUpdateDescriptorSetWithTemplateSized2GOOGLE vkUpdateDescriptorSetWithTemplateSized2GOOGLE;
 #endif
 #ifdef VK_EXT_global_priority_query
 #endif
+#ifdef VK_EXT_image_view_min_lod
+#endif
 #ifdef VK_EXT_multi_draw
     PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT;
     PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT;
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+#endif
+#ifdef VK_EXT_shader_tile_image
+#endif
+#ifdef VK_EXT_opacity_micromap
+    PFN_vkCreateMicromapEXT vkCreateMicromapEXT;
+    PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT;
+    PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT;
+    PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT;
+    PFN_vkCopyMicromapEXT vkCopyMicromapEXT;
+    PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT;
+    PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT;
+    PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT;
+    PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT;
+    PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT;
+    PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT;
+    PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT;
+    PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT;
+    PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT;
+#endif
+#ifdef VK_NV_displacement_micromap
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+    PFN_vkCmdDrawClusterHUAWEI vkCmdDrawClusterHUAWEI;
+    PFN_vkCmdDrawClusterIndirectHUAWEI vkCmdDrawClusterIndirectHUAWEI;
+#endif
 #ifdef VK_EXT_border_color_swizzle
 #endif
 #ifdef VK_EXT_pageable_device_local_memory
     PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT;
 #endif
+#ifdef VK_ARM_shader_core_properties
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+    PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE;
+    PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE;
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+#endif
+#ifdef VK_NV_copy_memory_indirect
+    PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV;
+    PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV;
+#endif
+#ifdef VK_NV_memory_decompression
+    PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV;
+    PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV;
+#endif
+#ifdef VK_NV_linear_color_attachment
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+#endif
+#ifdef VK_QCOM_image_processing
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+    PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT;
+    PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT;
+    PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT;
+    PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT;
+    PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT;
+    PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT;
+    PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT;
+    PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT;
+    PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT;
+    PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT;
+    PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT;
+    PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT;
+    PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT;
+    PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT;
+    PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT;
+    PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT;
+    PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT;
+    PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT;
+    PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT;
+    PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT;
+    PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT;
+    PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV;
+    PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV;
+    PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV;
+    PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV;
+    PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV;
+    PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV;
+    PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV;
+    PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV;
+    PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV;
+    PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV;
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+#endif
+#ifdef VK_EXT_shader_module_identifier
+    PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT;
+    PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT;
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+    PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV;
+    PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV;
+    PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV;
+    PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV;
+    PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV;
+#endif
+#ifdef VK_EXT_legacy_dithering
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+#endif
+#ifdef VK_EXT_shader_object
+    PFN_vkCreateShadersEXT vkCreateShadersEXT;
+    PFN_vkDestroyShaderEXT vkDestroyShaderEXT;
+    PFN_vkGetShaderBinaryDataEXT vkGetShaderBinaryDataEXT;
+    PFN_vkCmdBindShadersEXT vkCmdBindShadersEXT;
+#endif
+#ifdef VK_QCOM_tile_properties
+    PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM;
+    PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM;
+#endif
+#ifdef VK_SEC_amigo_profiling
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+    PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT vkCmdSetAttachmentFeedbackLoopEnableEXT;
+#endif
 #ifdef VK_KHR_acceleration_structure
     PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR;
     PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR;
@@ -1165,6 +1408,11 @@ struct VulkanDispatch {
 #endif
 #ifdef VK_KHR_ray_query
 #endif
+#ifdef VK_EXT_mesh_shader
+    PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT;
+    PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT;
+    PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT;
+#endif
 };
 
 }  // namespace vk
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_extension_structs.cpp b/stream-servers/vulkan/cereal/common/goldfish_vk_extension_structs.cpp
index b789a0df..5fd819d6 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_extension_structs.cpp
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_extension_structs.cpp
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_extension_structs
 //
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (impl) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -30,7 +30,6 @@
 //
 
 #include "goldfish_vk_extension_structs.h"
-
 namespace gfxstream {
 namespace vk {
 
@@ -40,6 +39,8 @@ namespace vk {
 #endif
 #ifdef VK_VERSION_1_2
 #endif
+#ifdef VK_VERSION_1_3
+#endif
 #ifdef VK_KHR_surface
 #endif
 #ifdef VK_KHR_swapchain
@@ -64,6 +65,8 @@ namespace vk {
 #endif
 #ifdef VK_KHR_video_decode_queue
 #endif
+#ifdef VK_KHR_video_decode_h264
+#endif
 #ifdef VK_KHR_dynamic_rendering
 #endif
 #ifdef VK_KHR_multiview
@@ -158,6 +161,10 @@ namespace vk {
 #endif
 #ifdef VK_KHR_shader_clock
 #endif
+#ifdef VK_KHR_video_decode_h265
+#endif
+#ifdef VK_KHR_global_priority
+#endif
 #ifdef VK_KHR_driver_properties
 #endif
 #ifdef VK_KHR_shader_float_controls
@@ -190,6 +197,8 @@ namespace vk {
 #endif
 #ifdef VK_KHR_pipeline_executable_properties
 #endif
+#ifdef VK_KHR_map_memory2
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -202,6 +211,8 @@ namespace vk {
 #endif
 #ifdef VK_KHR_synchronization2
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
@@ -212,8 +223,14 @@ namespace vk {
 #endif
 #ifdef VK_KHR_format_feature_flags2
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
 #ifdef VK_EXT_debug_report
@@ -254,8 +271,6 @@ namespace vk {
 #endif
 #ifdef VK_EXT_video_encode_h265
 #endif
-#ifdef VK_EXT_video_decode_h264
-#endif
 #ifdef VK_AMD_texture_gather_bias_lod
 #endif
 #ifdef VK_AMD_shader_info
@@ -288,6 +303,8 @@ namespace vk {
 #endif
 #ifdef VK_EXT_astc_decode_mode
 #endif
+#ifdef VK_EXT_pipeline_robustness
+#endif
 #ifdef VK_EXT_conditional_rendering
 #endif
 #ifdef VK_NV_clip_space_w_scaling
@@ -326,8 +343,6 @@ namespace vk {
 #endif
 #ifdef VK_MVK_macos_surface
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -392,8 +407,6 @@ namespace vk {
 #endif
 #ifdef VK_AMD_shader_core_properties
 #endif
-#ifdef VK_EXT_video_decode_h265
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 #endif
 #ifdef VK_EXT_vertex_attribute_divisor
@@ -484,6 +497,10 @@ namespace vk {
 #endif
 #ifdef VK_EXT_shader_atomic_float2
 #endif
+#ifdef VK_EXT_surface_maintenance1
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+#endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -504,6 +521,8 @@ namespace vk {
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+#endif
 #ifdef VK_EXT_private_data
 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
@@ -512,6 +531,16 @@ namespace vk {
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+#endif
+#ifdef VK_EXT_metal_objects
+#endif
+#ifdef VK_EXT_descriptor_buffer
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
 #endif
 #ifdef VK_NV_ray_tracing_motion_blur
@@ -524,8 +553,16 @@ namespace vk {
 #endif
 #ifdef VK_EXT_image_robustness
 #endif
+#ifdef VK_EXT_image_compression_control
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+#endif
 #ifdef VK_EXT_4444_formats
 #endif
+#ifdef VK_EXT_device_fault
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 #endif
 #ifdef VK_NV_acquire_winrt_display
@@ -538,6 +575,10 @@ namespace vk {
 #endif
 #ifdef VK_EXT_physical_device_drm
 #endif
+#ifdef VK_EXT_device_address_binding_report
+#endif
+#ifdef VK_EXT_depth_clip_control
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 #endif
 #ifdef VK_FUCHSIA_external_memory
@@ -552,30 +593,110 @@ namespace vk {
 #endif
 #ifdef VK_NV_external_memory_rdma
 #endif
+#ifdef VK_EXT_pipeline_properties
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 #endif
 #ifdef VK_QNX_screen_surface
 #endif
 #ifdef VK_EXT_color_write_enable
 #endif
+#ifdef VK_EXT_primitives_generated_query
+#endif
 #ifdef VK_GOOGLE_gfxstream
 #endif
 #ifdef VK_EXT_global_priority_query
 #endif
+#ifdef VK_EXT_image_view_min_lod
+#endif
 #ifdef VK_EXT_multi_draw
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+#endif
+#ifdef VK_EXT_shader_tile_image
+#endif
+#ifdef VK_EXT_opacity_micromap
+#endif
+#ifdef VK_NV_displacement_micromap
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+#endif
 #ifdef VK_EXT_border_color_swizzle
 #endif
 #ifdef VK_EXT_pageable_device_local_memory
 #endif
+#ifdef VK_ARM_shader_core_properties
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+#endif
+#ifdef VK_NV_copy_memory_indirect
+#endif
+#ifdef VK_NV_memory_decompression
+#endif
+#ifdef VK_NV_linear_color_attachment
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+#endif
+#ifdef VK_QCOM_image_processing
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+#endif
+#ifdef VK_EXT_shader_module_identifier
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+#endif
+#ifdef VK_EXT_legacy_dithering
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+#endif
+#ifdef VK_EXT_shader_object
+#endif
+#ifdef VK_QCOM_tile_properties
+#endif
+#ifdef VK_SEC_amigo_profiling
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+#endif
 #ifdef VK_KHR_acceleration_structure
 #endif
 #ifdef VK_KHR_ray_tracing_pipeline
 #endif
 #ifdef VK_KHR_ray_query
 #endif
+#ifdef VK_EXT_mesh_shader
+#endif
 uint32_t goldfish_vk_struct_type(const void* structExtension) {
     const uint32_t asStructType = *(reinterpret_cast<const uint32_t*>(structExtension));
     return asStructType;
@@ -587,6 +708,11 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
     }
     uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
     switch (structType) {
+#ifdef VK_VERSION_1_0
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
+            return sizeof(VkShaderModuleCreateInfo);
+        }
+#endif
 #ifdef VK_VERSION_1_1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
             return sizeof(VkPhysicalDeviceSubgroupProperties);
@@ -822,6 +948,95 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkMemoryOpaqueCaptureAddressAllocateInfo);
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
+            return sizeof(VkPhysicalDeviceVulkan13Features);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: {
+            return sizeof(VkPhysicalDeviceVulkan13Properties);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: {
+            return sizeof(VkPipelineCreationFeedbackCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
+            return sizeof(VkPhysicalDeviceShaderTerminateInvocationFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
+            return sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
+            return sizeof(VkPhysicalDevicePrivateDataFeatures);
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: {
+            return sizeof(VkDevicePrivateDataCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
+            return sizeof(VkPhysicalDevicePipelineCreationCacheControlFeatures);
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: {
+            return sizeof(VkMemoryBarrier2);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
+            return sizeof(VkPhysicalDeviceSynchronization2Features);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
+            return sizeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
+            return sizeof(VkPhysicalDeviceImageRobustnessFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
+            return sizeof(VkPhysicalDeviceSubgroupSizeControlFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
+            return sizeof(VkPhysicalDeviceSubgroupSizeControlProperties);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: {
+            return sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
+            return sizeof(VkPhysicalDeviceInlineUniformBlockFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
+            return sizeof(VkPhysicalDeviceInlineUniformBlockProperties);
+        }
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: {
+            return sizeof(VkWriteDescriptorSetInlineUniformBlock);
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: {
+            return sizeof(VkDescriptorPoolInlineUniformBlockCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
+            return sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: {
+            return sizeof(VkPipelineRenderingCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
+            return sizeof(VkPhysicalDeviceDynamicRenderingFeatures);
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: {
+            return sizeof(VkCommandBufferInheritanceRenderingInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
+            return sizeof(VkPhysicalDeviceShaderIntegerDotProductFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
+            return sizeof(VkPhysicalDeviceShaderIntegerDotProductProperties);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
+            return sizeof(VkPhysicalDeviceTexelBufferAlignmentProperties);
+        }
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
+            return sizeof(VkFormatProperties3);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
+            return sizeof(VkPhysicalDeviceMaintenance4Features);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
+            return sizeof(VkPhysicalDeviceMaintenance4Properties);
+        }
+#endif
 #ifdef VK_KHR_swapchain
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
             return sizeof(VkImageSwapchainCreateInfoKHR);
@@ -842,26 +1057,48 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
         }
 #endif
 #ifdef VK_KHR_video_queue
-        case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
-            return sizeof(VkVideoQueueFamilyProperties2KHR);
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: {
+            return sizeof(VkQueueFamilyQueryResultStatusPropertiesKHR);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
-            return sizeof(VkVideoProfileKHR);
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: {
+            return sizeof(VkQueueFamilyVideoPropertiesKHR);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
-            return sizeof(VkVideoProfilesKHR);
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: {
+            return sizeof(VkVideoProfileInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: {
+            return sizeof(VkVideoProfileListInfoKHR);
         }
 #endif
-#ifdef VK_KHR_dynamic_rendering
-        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
-            return sizeof(VkPipelineRenderingCreateInfoKHR);
+#ifdef VK_KHR_video_decode_queue
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: {
+            return sizeof(VkVideoDecodeCapabilitiesKHR);
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
-            return sizeof(VkPhysicalDeviceDynamicRenderingFeaturesKHR);
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: {
+            return sizeof(VkVideoDecodeUsageInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_video_decode_h264
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: {
+            return sizeof(VkVideoDecodeH264ProfileInfoKHR);
         }
-        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
-            return sizeof(VkCommandBufferInheritanceRenderingInfoKHR);
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: {
+            return sizeof(VkVideoDecodeH264CapabilitiesKHR);
         }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            return sizeof(VkVideoDecodeH264SessionParametersAddInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            return sizeof(VkVideoDecodeH264SessionParametersCreateInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: {
+            return sizeof(VkVideoDecodeH264PictureInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: {
+            return sizeof(VkVideoDecodeH264DpbSlotInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_dynamic_rendering
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
             return sizeof(VkRenderingFragmentShadingRateAttachmentInfoKHR);
         }
@@ -936,21 +1173,51 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
         }
 #endif
 #ifdef VK_KHR_portability_subset
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
             return sizeof(VkPhysicalDevicePortabilitySubsetFeaturesKHR);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
             return sizeof(VkPhysicalDevicePortabilitySubsetPropertiesKHR);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_shader_clock
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
             return sizeof(VkPhysicalDeviceShaderClockFeaturesKHR);
         }
 #endif
-#ifdef VK_KHR_shader_terminate_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
-            return sizeof(VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR);
+#ifdef VK_KHR_video_decode_h265
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: {
+            return sizeof(VkVideoDecodeH265ProfileInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: {
+            return sizeof(VkVideoDecodeH265CapabilitiesKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            return sizeof(VkVideoDecodeH265SessionParametersAddInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            return sizeof(VkVideoDecodeH265SessionParametersCreateInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: {
+            return sizeof(VkVideoDecodeH265PictureInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: {
+            return sizeof(VkVideoDecodeH265DpbSlotInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: {
+            return sizeof(VkDeviceQueueGlobalPriorityCreateInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: {
+            return sizeof(VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR);
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: {
+            return sizeof(VkQueueFamilyGlobalPriorityPropertiesKHR);
         }
 #endif
 #ifdef VK_KHR_fragment_shading_rate
@@ -982,12 +1249,9 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR);
         }
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
-            return sizeof(VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR);
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
-            return sizeof(VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR);
+#ifdef VK_KHR_pipeline_library
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+            return sizeof(VkPipelineLibraryCreateInfoKHR);
         }
 #endif
 #ifdef VK_KHR_present_id
@@ -999,47 +1263,63 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
         }
 #endif
 #ifdef VK_KHR_video_encode_queue
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: {
+            return sizeof(VkVideoEncodeCapabilitiesKHR);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: {
+            return sizeof(VkQueryPoolVideoEncodeFeedbackCreateInfoKHR);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: {
+            return sizeof(VkVideoEncodeUsageInfoKHR);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: {
+            return sizeof(VkVideoEncodeRateControlLayerInfoKHR);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
             return sizeof(VkVideoEncodeRateControlInfoKHR);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_synchronization2
-        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
-            return sizeof(VkMemoryBarrier2KHR);
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
-            return sizeof(VkPhysicalDeviceSynchronization2FeaturesKHR);
-        }
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
             return sizeof(VkQueueFamilyCheckpointProperties2NV);
         }
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
+            return sizeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: {
+            return sizeof(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR);
+        }
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
             return sizeof(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR);
         }
 #endif
-#ifdef VK_KHR_zero_initialize_workgroup_memory
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
-            return sizeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR);
-        }
-#endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
             return sizeof(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR);
         }
 #endif
-#ifdef VK_KHR_format_feature_flags2
-        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
-            return sizeof(VkFormatProperties3KHR);
+#ifdef VK_KHR_ray_tracing_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
+            return sizeof(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR);
         }
 #endif
-#ifdef VK_KHR_maintenance4
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
-            return sizeof(VkPhysicalDeviceMaintenance4FeaturesKHR);
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
-            return sizeof(VkPhysicalDeviceMaintenance4PropertiesKHR);
+#ifdef VK_KHR_ray_tracing_position_fetch
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
+            return sizeof(VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR);
         }
 #endif
 #ifdef VK_ANDROID_native_buffer
@@ -1080,76 +1360,88 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
         }
 #endif
 #ifdef VK_EXT_video_encode_h264
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
             return sizeof(VkVideoEncodeH264CapabilitiesEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
-            return sizeof(VkVideoEncodeH264SessionCreateInfoEXT);
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
             return sizeof(VkVideoEncodeH264SessionParametersAddInfoEXT);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             return sizeof(VkVideoEncodeH264SessionParametersCreateInfoEXT);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
             return sizeof(VkVideoEncodeH264VclFrameInfoEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
-            return sizeof(VkVideoEncodeH264EmitPictureParametersEXT);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: {
+            return sizeof(VkVideoEncodeH264DpbSlotInfoEXT);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: {
+            return sizeof(VkVideoEncodeH264ProfileInfoEXT);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: {
+            return sizeof(VkVideoEncodeH264RateControlInfoEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
-            return sizeof(VkVideoEncodeH264ProfileEXT);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: {
+            return sizeof(VkVideoEncodeH264RateControlLayerInfoEXT);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_EXT_video_encode_h265
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
             return sizeof(VkVideoEncodeH265CapabilitiesEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
-            return sizeof(VkVideoEncodeH265SessionCreateInfoEXT);
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
             return sizeof(VkVideoEncodeH265SessionParametersAddInfoEXT);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             return sizeof(VkVideoEncodeH265SessionParametersCreateInfoEXT);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
             return sizeof(VkVideoEncodeH265VclFrameInfoEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
-            return sizeof(VkVideoEncodeH265EmitPictureParametersEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
-            return sizeof(VkVideoEncodeH265ProfileEXT);
-        }
-#endif
-#ifdef VK_EXT_video_decode_h264
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
-            return sizeof(VkVideoDecodeH264ProfileEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
-            return sizeof(VkVideoDecodeH264CapabilitiesEXT);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: {
+            return sizeof(VkVideoEncodeH265DpbSlotInfoEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
-            return sizeof(VkVideoDecodeH264SessionCreateInfoEXT);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: {
+            return sizeof(VkVideoEncodeH265ProfileInfoEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            return sizeof(VkVideoDecodeH264SessionParametersAddInfoEXT);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: {
+            return sizeof(VkVideoEncodeH265RateControlInfoEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            return sizeof(VkVideoDecodeH264SessionParametersCreateInfoEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
-            return sizeof(VkVideoDecodeH264PictureInfoEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
-            return sizeof(VkVideoDecodeH264MvcEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
-            return sizeof(VkVideoDecodeH264DpbSlotInfoEXT);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: {
+            return sizeof(VkVideoEncodeH265RateControlLayerInfoEXT);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
@@ -1187,11 +1479,6 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkValidationFlagsEXT);
         }
 #endif
-#ifdef VK_EXT_texture_compression_astc_hdr
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
-            return sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT);
-        }
-#endif
 #ifdef VK_EXT_astc_decode_mode
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
             return sizeof(VkImageViewASTCDecodeModeEXT);
@@ -1200,6 +1487,17 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT);
         }
 #endif
+#ifdef VK_EXT_pipeline_robustness
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: {
+            return sizeof(VkPhysicalDevicePipelineRobustnessFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDevicePipelineRobustnessPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: {
+            return sizeof(VkPipelineRobustnessCreateInfoEXT);
+        }
+#endif
 #ifdef VK_EXT_conditional_rendering
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
             return sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT);
@@ -1258,6 +1556,9 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
         }
 #endif
 #ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+            return sizeof(VkDebugUtilsObjectNameInfoEXT);
+        }
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
             return sizeof(VkDebugUtilsMessengerCreateInfoEXT);
         }
@@ -1279,20 +1580,6 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkAndroidHardwareBufferFormatProperties2ANDROID);
         }
 #endif
-#ifdef VK_EXT_inline_uniform_block
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
-            return sizeof(VkPhysicalDeviceInlineUniformBlockFeaturesEXT);
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
-            return sizeof(VkPhysicalDeviceInlineUniformBlockPropertiesEXT);
-        }
-        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
-            return sizeof(VkWriteDescriptorSetInlineUniformBlockEXT);
-        }
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
-            return sizeof(VkDescriptorPoolInlineUniformBlockCreateInfoEXT);
-        }
-#endif
 #ifdef VK_EXT_sample_locations
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
             return sizeof(VkSampleLocationsInfoEXT);
@@ -1396,11 +1683,6 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkFilterCubicImageViewImageFormatPropertiesEXT);
         }
 #endif
-#ifdef VK_EXT_global_priority
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
-            return sizeof(VkDeviceQueueGlobalPriorityCreateInfoEXT);
-        }
-#endif
 #ifdef VK_EXT_external_memory_host
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
             return sizeof(VkImportMemoryHostPointerInfoEXT);
@@ -1419,29 +1701,6 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPhysicalDeviceShaderCorePropertiesAMD);
         }
 #endif
-#ifdef VK_EXT_video_decode_h265
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
-            return sizeof(VkVideoDecodeH265ProfileEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
-            return sizeof(VkVideoDecodeH265CapabilitiesEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
-            return sizeof(VkVideoDecodeH265SessionCreateInfoEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            return sizeof(VkVideoDecodeH265SessionParametersAddInfoEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            return sizeof(VkVideoDecodeH265SessionParametersCreateInfoEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
-            return sizeof(VkVideoDecodeH265PictureInfoEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
-            return sizeof(VkVideoDecodeH265DpbSlotInfoEXT);
-        }
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
             return sizeof(VkDeviceMemoryOverallocationCreateInfoAMD);
@@ -1463,11 +1722,6 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPresentFrameTokenGGP);
         }
 #endif
-#ifdef VK_EXT_pipeline_creation_feedback
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
-            return sizeof(VkPipelineCreationFeedbackCreateInfoEXT);
-        }
-#endif
 #ifdef VK_NV_compute_shader_derivatives
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
             return sizeof(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV);
@@ -1481,11 +1735,6 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPhysicalDeviceMeshShaderPropertiesNV);
         }
 #endif
-#ifdef VK_NV_fragment_shader_barycentric
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
-            return sizeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV);
-        }
-#endif
 #ifdef VK_NV_shader_image_footprint
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
             return sizeof(VkPhysicalDeviceShaderImageFootprintFeaturesNV);
@@ -1585,17 +1834,6 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             }
         }
 #endif
-#ifdef VK_EXT_subgroup_size_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
-            return sizeof(VkPhysicalDeviceSubgroupSizeControlFeaturesEXT);
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
-            return sizeof(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT);
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
-            return sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT);
-        }
-#endif
 #ifdef VK_AMD_shader_core_properties2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
             return sizeof(VkPhysicalDeviceShaderCoreProperties2AMD);
@@ -1721,9 +1959,32 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT);
         }
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
-            return sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT);
+#ifdef VK_EXT_surface_maintenance1
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: {
+            return sizeof(VkSurfacePresentModeEXT);
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
+            return sizeof(VkSurfacePresentScalingCapabilitiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
+            return sizeof(VkSurfacePresentModeCompatibilityEXT);
+        }
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: {
+            return sizeof(VkSwapchainPresentFenceInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: {
+            return sizeof(VkSwapchainPresentModesCreateInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: {
+            return sizeof(VkSwapchainPresentModeInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: {
+            return sizeof(VkSwapchainPresentScalingCreateInfoEXT);
         }
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -1749,9 +2010,6 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
             return sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT);
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
-            return sizeof(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT);
-        }
 #endif
 #ifdef VK_QCOM_render_pass_transform
         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
@@ -1788,17 +2046,15 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT);
         }
 #endif
-#ifdef VK_EXT_private_data
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
-            return sizeof(VkPhysicalDevicePrivateDataFeaturesEXT);
+#ifdef VK_NV_present_barrier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
+            return sizeof(VkPhysicalDevicePresentBarrierFeaturesNV);
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
-            return sizeof(VkDevicePrivateDataCreateInfoEXT);
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: {
+            return sizeof(VkSurfaceCapabilitiesPresentBarrierNV);
         }
-#endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
-            return sizeof(VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT);
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: {
+            return sizeof(VkSwapchainPresentBarrierCreateInfoNV);
         }
 #endif
 #ifdef VK_NV_device_diagnostics_config
@@ -1809,6 +2065,79 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkDeviceDiagnosticsConfigCreateInfoNV);
         }
 #endif
+#ifdef VK_NV_low_latency
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: {
+            return sizeof(VkQueryLowLatencySupportNV);
+        }
+#endif
+#ifdef VK_EXT_metal_objects
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: {
+            return sizeof(VkExportMetalObjectCreateInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: {
+            return sizeof(VkExportMetalDeviceInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: {
+            return sizeof(VkExportMetalCommandQueueInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: {
+            return sizeof(VkExportMetalBufferInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: {
+            return sizeof(VkImportMetalBufferInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: {
+            return sizeof(VkExportMetalTextureInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: {
+            return sizeof(VkImportMetalTextureInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: {
+            return sizeof(VkExportMetalIOSurfaceInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: {
+            return sizeof(VkImportMetalIOSurfaceInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            return sizeof(VkExportMetalSharedEventInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            return sizeof(VkImportMetalSharedEventInfoEXT);
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceDescriptorBufferPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceDescriptorBufferFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: {
+            return sizeof(VkDescriptorBufferBindingPushDescriptorBufferHandleEXT);
+        }
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: {
+            return sizeof(VkOpaqueCaptureDescriptorDataCreateInfoEXT);
+        }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: {
+            return sizeof(VkGraphicsPipelineLibraryCreateInfoEXT);
+        }
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
+            return sizeof(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD);
+        }
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
             return sizeof(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV);
@@ -1849,9 +2178,20 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkCopyCommandTransformInfoQCOM);
         }
 #endif
-#ifdef VK_EXT_image_robustness
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
-            return sizeof(VkPhysicalDeviceImageRobustnessFeaturesEXT);
+#ifdef VK_EXT_image_compression_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceImageCompressionControlFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
+            return sizeof(VkImageCompressionControlEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
+            return sizeof(VkImageCompressionPropertiesEXT);
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT);
         }
 #endif
 #ifdef VK_EXT_4444_formats
@@ -1859,17 +2199,27 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPhysicalDevice4444FormatsFeaturesEXT);
         }
 #endif
+#ifdef VK_EXT_device_fault
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceFaultFeaturesEXT);
+        }
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT);
+        }
+#endif
 #ifdef VK_EXT_rgba10x6_formats
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
             return sizeof(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT);
         }
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
-            return sizeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE);
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT);
         }
-        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
-            return sizeof(VkMutableDescriptorTypeCreateInfoVALVE);
+        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: {
+            return sizeof(VkMutableDescriptorTypeCreateInfoEXT);
         }
 #endif
 #ifdef VK_EXT_vertex_input_dynamic_state
@@ -1882,6 +2232,22 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPhysicalDeviceDrmPropertiesEXT);
         }
 #endif
+#ifdef VK_EXT_device_address_binding_report
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceAddressBindingReportFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: {
+            return sizeof(VkDeviceAddressBindingCallbackDataEXT);
+        }
+#endif
+#ifdef VK_EXT_depth_clip_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceDepthClipControlFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: {
+            return sizeof(VkPipelineViewportDepthClipControlCreateInfoEXT);
+        }
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
             return sizeof(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT);
@@ -1924,6 +2290,22 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV);
         }
 #endif
+#ifdef VK_EXT_pipeline_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
+            return sizeof(VkPhysicalDevicePipelinePropertiesFeaturesEXT);
+        }
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: {
+            return sizeof(VkSubpassResolvePerformanceQueryEXT);
+        }
+        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: {
+            return sizeof(VkMultisampledRenderToSingleSampledInfoEXT);
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
             return sizeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT);
@@ -1937,6 +2319,11 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPipelineColorWriteCreateInfoEXT);
         }
 #endif
+#ifdef VK_EXT_primitives_generated_query
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
+            return sizeof(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT);
+        }
+#endif
 #ifdef VK_GOOGLE_gfxstream
         case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
             return sizeof(VkImportColorBufferGOOGLE);
@@ -1948,12 +2335,12 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkCreateBlobGOOGLE);
         }
 #endif
-#ifdef VK_EXT_global_priority_query
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
-            return sizeof(VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT);
+#ifdef VK_EXT_image_view_min_lod
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceImageViewMinLodFeaturesEXT);
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
-            return sizeof(VkQueueFamilyGlobalPriorityPropertiesEXT);
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: {
+            return sizeof(VkImageViewMinLodCreateInfoEXT);
         }
 #endif
 #ifdef VK_EXT_multi_draw
@@ -1964,6 +2351,55 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPhysicalDeviceMultiDrawPropertiesEXT);
         }
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT);
+        }
+#endif
+#ifdef VK_EXT_shader_tile_image
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceShaderTileImageFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceShaderTileImagePropertiesEXT);
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceOpacityMicromapFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceOpacityMicromapPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: {
+            return sizeof(VkAccelerationStructureTrianglesOpacityMicromapEXT);
+        }
+#endif
+#ifdef VK_NV_displacement_micromap
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
+            return sizeof(VkPhysicalDeviceDisplacementMicromapFeaturesNV);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: {
+            return sizeof(VkPhysicalDeviceDisplacementMicromapPropertiesNV);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: {
+            return sizeof(VkAccelerationStructureTrianglesDisplacementMicromapNV);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
+            return sizeof(VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: {
+            return sizeof(VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI);
+        }
+#endif
 #ifdef VK_EXT_border_color_swizzle
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
             return sizeof(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT);
@@ -1977,6 +2413,204 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT);
         }
 #endif
+#ifdef VK_ARM_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: {
+            return sizeof(VkPhysicalDeviceShaderCorePropertiesARM);
+        }
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: {
+            return sizeof(VkImageViewSlicedCreateInfoEXT);
+        }
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
+            return sizeof(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE);
+        }
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceDepthClampZeroOneFeaturesEXT);
+        }
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT);
+        }
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: {
+            return sizeof(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: {
+            return sizeof(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM);
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: {
+            return sizeof(VkSubpassFragmentDensityMapOffsetEndInfoQCOM);
+        }
+#endif
+#ifdef VK_NV_copy_memory_indirect
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
+            return sizeof(VkPhysicalDeviceCopyMemoryIndirectFeaturesNV);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: {
+            return sizeof(VkPhysicalDeviceCopyMemoryIndirectPropertiesNV);
+        }
+#endif
+#ifdef VK_NV_memory_decompression
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: {
+            return sizeof(VkPhysicalDeviceMemoryDecompressionFeaturesNV);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: {
+            return sizeof(VkPhysicalDeviceMemoryDecompressionPropertiesNV);
+        }
+#endif
+#ifdef VK_NV_linear_color_attachment
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
+            return sizeof(VkPhysicalDeviceLinearColorAttachmentFeaturesNV);
+        }
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT);
+        }
+#endif
+#ifdef VK_QCOM_image_processing
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: {
+            return sizeof(VkImageViewSampleWeightCreateInfoQCOM);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
+            return sizeof(VkPhysicalDeviceImageProcessingFeaturesQCOM);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: {
+            return sizeof(VkPhysicalDeviceImageProcessingPropertiesQCOM);
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceExtendedDynamicState3PropertiesEXT);
+        }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: {
+            return sizeof(VkRenderPassCreationControlEXT);
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+            return sizeof(VkRenderPassCreationFeedbackCreateInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: {
+            return sizeof(VkRenderPassSubpassFeedbackCreateInfoEXT);
+        }
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: {
+            return sizeof(VkDirectDriverLoadingListLUNARG);
+        }
+#endif
+#ifdef VK_EXT_shader_module_identifier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: {
+            return sizeof(VkPipelineShaderStageModuleIdentifierCreateInfoEXT);
+        }
+#endif
+#ifdef VK_NV_optical_flow
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
+            return sizeof(VkPhysicalDeviceOpticalFlowFeaturesNV);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: {
+            return sizeof(VkPhysicalDeviceOpticalFlowPropertiesNV);
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: {
+            return sizeof(VkOpticalFlowImageFormatInfoNV);
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: {
+            return sizeof(VkOpticalFlowSessionCreatePrivateDataInfoNV);
+        }
+#endif
+#ifdef VK_EXT_legacy_dithering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceLegacyDitheringFeaturesEXT);
+        }
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: {
+            return sizeof(VkPhysicalDevicePipelineProtectedAccessFeaturesEXT);
+        }
+#endif
+#ifdef VK_EXT_shader_object
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceShaderObjectFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceShaderObjectPropertiesEXT);
+        }
+#endif
+#ifdef VK_QCOM_tile_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
+            return sizeof(VkPhysicalDeviceTilePropertiesFeaturesQCOM);
+        }
+#endif
+#ifdef VK_SEC_amigo_profiling
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
+            return sizeof(VkPhysicalDeviceAmigoProfilingFeaturesSEC);
+        }
+        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: {
+            return sizeof(VkAmigoProfilingSubmitInfoSEC);
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
+            return sizeof(VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM);
+        }
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: {
+            return sizeof(VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
+            return sizeof(VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV);
+        }
+#endif
+#ifdef VK_ARM_shader_core_builtins
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
+            return sizeof(VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: {
+            return sizeof(VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM);
+        }
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
+            return sizeof(VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT);
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
+            return sizeof(VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM);
+        }
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: {
+            return sizeof(VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM);
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT);
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
             return sizeof(VkWriteDescriptorSetAccelerationStructureKHR);
@@ -2001,6 +2635,14 @@ size_t goldfish_vk_extension_struct_size(VkStructureType rootType, const void* s
             return sizeof(VkPhysicalDeviceRayQueryFeaturesKHR);
         }
 #endif
+#ifdef VK_EXT_mesh_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceMeshShaderFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceMeshShaderPropertiesEXT);
+        }
+#endif
         default: {
             return (size_t)0;
         }
@@ -2015,6 +2657,11 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
     }
     uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
     switch (structType) {
+#ifdef VK_VERSION_1_0
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
+            return sizeof(VkShaderModuleCreateInfo);
+        }
+#endif
 #ifdef VK_VERSION_1_1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
             return sizeof(VkPhysicalDeviceSubgroupProperties);
@@ -2254,6 +2901,95 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkMemoryOpaqueCaptureAddressAllocateInfo);
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
+            return sizeof(VkPhysicalDeviceVulkan13Features);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: {
+            return sizeof(VkPhysicalDeviceVulkan13Properties);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: {
+            return sizeof(VkPipelineCreationFeedbackCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
+            return sizeof(VkPhysicalDeviceShaderTerminateInvocationFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
+            return sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
+            return sizeof(VkPhysicalDevicePrivateDataFeatures);
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: {
+            return sizeof(VkDevicePrivateDataCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
+            return sizeof(VkPhysicalDevicePipelineCreationCacheControlFeatures);
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: {
+            return sizeof(VkMemoryBarrier2);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
+            return sizeof(VkPhysicalDeviceSynchronization2Features);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
+            return sizeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
+            return sizeof(VkPhysicalDeviceImageRobustnessFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
+            return sizeof(VkPhysicalDeviceSubgroupSizeControlFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
+            return sizeof(VkPhysicalDeviceSubgroupSizeControlProperties);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: {
+            return sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
+            return sizeof(VkPhysicalDeviceInlineUniformBlockFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
+            return sizeof(VkPhysicalDeviceInlineUniformBlockProperties);
+        }
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: {
+            return sizeof(VkWriteDescriptorSetInlineUniformBlock);
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: {
+            return sizeof(VkDescriptorPoolInlineUniformBlockCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
+            return sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: {
+            return sizeof(VkPipelineRenderingCreateInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
+            return sizeof(VkPhysicalDeviceDynamicRenderingFeatures);
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: {
+            return sizeof(VkCommandBufferInheritanceRenderingInfo);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
+            return sizeof(VkPhysicalDeviceShaderIntegerDotProductFeatures);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
+            return sizeof(VkPhysicalDeviceShaderIntegerDotProductProperties);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
+            return sizeof(VkPhysicalDeviceTexelBufferAlignmentProperties);
+        }
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
+            return sizeof(VkFormatProperties3);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
+            return sizeof(VkPhysicalDeviceMaintenance4Features);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
+            return sizeof(VkPhysicalDeviceMaintenance4Properties);
+        }
+#endif
 #ifdef VK_KHR_swapchain
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
             return sizeof(VkImageSwapchainCreateInfoKHR);
@@ -2274,26 +3010,48 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
         }
 #endif
 #ifdef VK_KHR_video_queue
-        case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
-            return sizeof(VkVideoQueueFamilyProperties2KHR);
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: {
+            return sizeof(VkQueueFamilyQueryResultStatusPropertiesKHR);
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: {
+            return sizeof(VkQueueFamilyVideoPropertiesKHR);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
-            return sizeof(VkVideoProfileKHR);
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: {
+            return sizeof(VkVideoProfileInfoKHR);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
-            return sizeof(VkVideoProfilesKHR);
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: {
+            return sizeof(VkVideoProfileListInfoKHR);
         }
 #endif
-#ifdef VK_KHR_dynamic_rendering
-        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
-            return sizeof(VkPipelineRenderingCreateInfoKHR);
+#ifdef VK_KHR_video_decode_queue
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: {
+            return sizeof(VkVideoDecodeCapabilitiesKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: {
+            return sizeof(VkVideoDecodeUsageInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_video_decode_h264
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: {
+            return sizeof(VkVideoDecodeH264ProfileInfoKHR);
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
-            return sizeof(VkPhysicalDeviceDynamicRenderingFeaturesKHR);
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: {
+            return sizeof(VkVideoDecodeH264CapabilitiesKHR);
         }
-        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
-            return sizeof(VkCommandBufferInheritanceRenderingInfoKHR);
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            return sizeof(VkVideoDecodeH264SessionParametersAddInfoKHR);
         }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            return sizeof(VkVideoDecodeH264SessionParametersCreateInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: {
+            return sizeof(VkVideoDecodeH264PictureInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: {
+            return sizeof(VkVideoDecodeH264DpbSlotInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_dynamic_rendering
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
             return sizeof(VkRenderingFragmentShadingRateAttachmentInfoKHR);
         }
@@ -2368,21 +3126,51 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
         }
 #endif
 #ifdef VK_KHR_portability_subset
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
             return sizeof(VkPhysicalDevicePortabilitySubsetFeaturesKHR);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
             return sizeof(VkPhysicalDevicePortabilitySubsetPropertiesKHR);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_shader_clock
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
             return sizeof(VkPhysicalDeviceShaderClockFeaturesKHR);
         }
 #endif
-#ifdef VK_KHR_shader_terminate_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
-            return sizeof(VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR);
+#ifdef VK_KHR_video_decode_h265
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: {
+            return sizeof(VkVideoDecodeH265ProfileInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: {
+            return sizeof(VkVideoDecodeH265CapabilitiesKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            return sizeof(VkVideoDecodeH265SessionParametersAddInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            return sizeof(VkVideoDecodeH265SessionParametersCreateInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: {
+            return sizeof(VkVideoDecodeH265PictureInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: {
+            return sizeof(VkVideoDecodeH265DpbSlotInfoKHR);
+        }
+#endif
+#ifdef VK_KHR_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: {
+            return sizeof(VkDeviceQueueGlobalPriorityCreateInfoKHR);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: {
+            return sizeof(VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR);
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: {
+            return sizeof(VkQueueFamilyGlobalPriorityPropertiesKHR);
         }
 #endif
 #ifdef VK_KHR_fragment_shading_rate
@@ -2414,12 +3202,9 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR);
         }
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
-            return sizeof(VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR);
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
-            return sizeof(VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR);
+#ifdef VK_KHR_pipeline_library
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+            return sizeof(VkPipelineLibraryCreateInfoKHR);
         }
 #endif
 #ifdef VK_KHR_present_id
@@ -2431,47 +3216,63 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
         }
 #endif
 #ifdef VK_KHR_video_encode_queue
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: {
+            return sizeof(VkVideoEncodeCapabilitiesKHR);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: {
+            return sizeof(VkQueryPoolVideoEncodeFeedbackCreateInfoKHR);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: {
+            return sizeof(VkVideoEncodeUsageInfoKHR);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: {
+            return sizeof(VkVideoEncodeRateControlLayerInfoKHR);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
             return sizeof(VkVideoEncodeRateControlInfoKHR);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_synchronization2
-        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
-            return sizeof(VkMemoryBarrier2KHR);
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
-            return sizeof(VkPhysicalDeviceSynchronization2FeaturesKHR);
-        }
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
             return sizeof(VkQueueFamilyCheckpointProperties2NV);
         }
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
+            return sizeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: {
+            return sizeof(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR);
+        }
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
             return sizeof(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR);
         }
 #endif
-#ifdef VK_KHR_zero_initialize_workgroup_memory
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
-            return sizeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR);
-        }
-#endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
             return sizeof(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR);
         }
 #endif
-#ifdef VK_KHR_format_feature_flags2
-        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
-            return sizeof(VkFormatProperties3KHR);
+#ifdef VK_KHR_ray_tracing_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
+            return sizeof(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR);
         }
 #endif
-#ifdef VK_KHR_maintenance4
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
-            return sizeof(VkPhysicalDeviceMaintenance4FeaturesKHR);
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
-            return sizeof(VkPhysicalDeviceMaintenance4PropertiesKHR);
+#ifdef VK_KHR_ray_tracing_position_fetch
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
+            return sizeof(VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR);
         }
 #endif
 #ifdef VK_ANDROID_native_buffer
@@ -2512,76 +3313,88 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
         }
 #endif
 #ifdef VK_EXT_video_encode_h264
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
             return sizeof(VkVideoEncodeH264CapabilitiesEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
-            return sizeof(VkVideoEncodeH264SessionCreateInfoEXT);
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
             return sizeof(VkVideoEncodeH264SessionParametersAddInfoEXT);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             return sizeof(VkVideoEncodeH264SessionParametersCreateInfoEXT);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
             return sizeof(VkVideoEncodeH264VclFrameInfoEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
-            return sizeof(VkVideoEncodeH264EmitPictureParametersEXT);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: {
+            return sizeof(VkVideoEncodeH264DpbSlotInfoEXT);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: {
+            return sizeof(VkVideoEncodeH264ProfileInfoEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
-            return sizeof(VkVideoEncodeH264ProfileEXT);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: {
+            return sizeof(VkVideoEncodeH264RateControlInfoEXT);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: {
+            return sizeof(VkVideoEncodeH264RateControlLayerInfoEXT);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_EXT_video_encode_h265
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
             return sizeof(VkVideoEncodeH265CapabilitiesEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
-            return sizeof(VkVideoEncodeH265SessionCreateInfoEXT);
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
             return sizeof(VkVideoEncodeH265SessionParametersAddInfoEXT);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             return sizeof(VkVideoEncodeH265SessionParametersCreateInfoEXT);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
             return sizeof(VkVideoEncodeH265VclFrameInfoEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
-            return sizeof(VkVideoEncodeH265EmitPictureParametersEXT);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: {
+            return sizeof(VkVideoEncodeH265DpbSlotInfoEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
-            return sizeof(VkVideoEncodeH265ProfileEXT);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: {
+            return sizeof(VkVideoEncodeH265ProfileInfoEXT);
         }
-#endif
-#ifdef VK_EXT_video_decode_h264
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
-            return sizeof(VkVideoDecodeH264ProfileEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
-            return sizeof(VkVideoDecodeH264CapabilitiesEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
-            return sizeof(VkVideoDecodeH264SessionCreateInfoEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            return sizeof(VkVideoDecodeH264SessionParametersAddInfoEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            return sizeof(VkVideoDecodeH264SessionParametersCreateInfoEXT);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: {
+            return sizeof(VkVideoEncodeH265RateControlInfoEXT);
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
-            return sizeof(VkVideoDecodeH264PictureInfoEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
-            return sizeof(VkVideoDecodeH264MvcEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
-            return sizeof(VkVideoDecodeH264DpbSlotInfoEXT);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: {
+            return sizeof(VkVideoEncodeH265RateControlLayerInfoEXT);
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
@@ -2619,11 +3432,6 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkValidationFlagsEXT);
         }
 #endif
-#ifdef VK_EXT_texture_compression_astc_hdr
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
-            return sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT);
-        }
-#endif
 #ifdef VK_EXT_astc_decode_mode
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
             return sizeof(VkImageViewASTCDecodeModeEXT);
@@ -2632,6 +3440,17 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT);
         }
 #endif
+#ifdef VK_EXT_pipeline_robustness
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: {
+            return sizeof(VkPhysicalDevicePipelineRobustnessFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDevicePipelineRobustnessPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: {
+            return sizeof(VkPipelineRobustnessCreateInfoEXT);
+        }
+#endif
 #ifdef VK_EXT_conditional_rendering
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
             return sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT);
@@ -2690,6 +3509,9 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
         }
 #endif
 #ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+            return sizeof(VkDebugUtilsObjectNameInfoEXT);
+        }
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
             return sizeof(VkDebugUtilsMessengerCreateInfoEXT);
         }
@@ -2711,20 +3533,6 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkAndroidHardwareBufferFormatProperties2ANDROID);
         }
 #endif
-#ifdef VK_EXT_inline_uniform_block
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
-            return sizeof(VkPhysicalDeviceInlineUniformBlockFeaturesEXT);
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
-            return sizeof(VkPhysicalDeviceInlineUniformBlockPropertiesEXT);
-        }
-        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
-            return sizeof(VkWriteDescriptorSetInlineUniformBlockEXT);
-        }
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
-            return sizeof(VkDescriptorPoolInlineUniformBlockCreateInfoEXT);
-        }
-#endif
 #ifdef VK_EXT_sample_locations
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
             return sizeof(VkSampleLocationsInfoEXT);
@@ -2828,11 +3636,6 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkFilterCubicImageViewImageFormatPropertiesEXT);
         }
 #endif
-#ifdef VK_EXT_global_priority
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
-            return sizeof(VkDeviceQueueGlobalPriorityCreateInfoEXT);
-        }
-#endif
 #ifdef VK_EXT_external_memory_host
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
             return sizeof(VkImportMemoryHostPointerInfoEXT);
@@ -2851,29 +3654,6 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPhysicalDeviceShaderCorePropertiesAMD);
         }
 #endif
-#ifdef VK_EXT_video_decode_h265
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
-            return sizeof(VkVideoDecodeH265ProfileEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
-            return sizeof(VkVideoDecodeH265CapabilitiesEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
-            return sizeof(VkVideoDecodeH265SessionCreateInfoEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            return sizeof(VkVideoDecodeH265SessionParametersAddInfoEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            return sizeof(VkVideoDecodeH265SessionParametersCreateInfoEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
-            return sizeof(VkVideoDecodeH265PictureInfoEXT);
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
-            return sizeof(VkVideoDecodeH265DpbSlotInfoEXT);
-        }
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
             return sizeof(VkDeviceMemoryOverallocationCreateInfoAMD);
@@ -2895,11 +3675,6 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPresentFrameTokenGGP);
         }
 #endif
-#ifdef VK_EXT_pipeline_creation_feedback
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
-            return sizeof(VkPipelineCreationFeedbackCreateInfoEXT);
-        }
-#endif
 #ifdef VK_NV_compute_shader_derivatives
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
             return sizeof(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV);
@@ -2913,11 +3688,6 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPhysicalDeviceMeshShaderPropertiesNV);
         }
 #endif
-#ifdef VK_NV_fragment_shader_barycentric
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
-            return sizeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV);
-        }
-#endif
 #ifdef VK_NV_shader_image_footprint
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
             return sizeof(VkPhysicalDeviceShaderImageFootprintFeaturesNV);
@@ -3017,17 +3787,6 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             }
         }
 #endif
-#ifdef VK_EXT_subgroup_size_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
-            return sizeof(VkPhysicalDeviceSubgroupSizeControlFeaturesEXT);
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
-            return sizeof(VkPhysicalDeviceSubgroupSizeControlPropertiesEXT);
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
-            return sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT);
-        }
-#endif
 #ifdef VK_AMD_shader_core_properties2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
             return sizeof(VkPhysicalDeviceShaderCoreProperties2AMD);
@@ -3153,9 +3912,32 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT);
         }
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
-            return sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT);
+#ifdef VK_EXT_surface_maintenance1
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: {
+            return sizeof(VkSurfacePresentModeEXT);
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
+            return sizeof(VkSurfacePresentScalingCapabilitiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
+            return sizeof(VkSurfacePresentModeCompatibilityEXT);
+        }
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: {
+            return sizeof(VkSwapchainPresentFenceInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: {
+            return sizeof(VkSwapchainPresentModesCreateInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: {
+            return sizeof(VkSwapchainPresentModeInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: {
+            return sizeof(VkSwapchainPresentScalingCreateInfoEXT);
         }
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -3181,9 +3963,6 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
             return sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT);
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
-            return sizeof(VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT);
-        }
 #endif
 #ifdef VK_QCOM_render_pass_transform
         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
@@ -3220,17 +3999,15 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT);
         }
 #endif
-#ifdef VK_EXT_private_data
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
-            return sizeof(VkPhysicalDevicePrivateDataFeaturesEXT);
+#ifdef VK_NV_present_barrier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
+            return sizeof(VkPhysicalDevicePresentBarrierFeaturesNV);
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
-            return sizeof(VkDevicePrivateDataCreateInfoEXT);
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: {
+            return sizeof(VkSurfaceCapabilitiesPresentBarrierNV);
         }
-#endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
-            return sizeof(VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT);
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: {
+            return sizeof(VkSwapchainPresentBarrierCreateInfoNV);
         }
 #endif
 #ifdef VK_NV_device_diagnostics_config
@@ -3241,6 +4018,79 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkDeviceDiagnosticsConfigCreateInfoNV);
         }
 #endif
+#ifdef VK_NV_low_latency
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: {
+            return sizeof(VkQueryLowLatencySupportNV);
+        }
+#endif
+#ifdef VK_EXT_metal_objects
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: {
+            return sizeof(VkExportMetalObjectCreateInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: {
+            return sizeof(VkExportMetalDeviceInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: {
+            return sizeof(VkExportMetalCommandQueueInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: {
+            return sizeof(VkExportMetalBufferInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: {
+            return sizeof(VkImportMetalBufferInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: {
+            return sizeof(VkExportMetalTextureInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: {
+            return sizeof(VkImportMetalTextureInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: {
+            return sizeof(VkExportMetalIOSurfaceInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: {
+            return sizeof(VkImportMetalIOSurfaceInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            return sizeof(VkExportMetalSharedEventInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            return sizeof(VkImportMetalSharedEventInfoEXT);
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceDescriptorBufferPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceDescriptorBufferFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: {
+            return sizeof(VkDescriptorBufferBindingPushDescriptorBufferHandleEXT);
+        }
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: {
+            return sizeof(VkOpaqueCaptureDescriptorDataCreateInfoEXT);
+        }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: {
+            return sizeof(VkGraphicsPipelineLibraryCreateInfoEXT);
+        }
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
+            return sizeof(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD);
+        }
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
             return sizeof(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV);
@@ -3281,9 +4131,20 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkCopyCommandTransformInfoQCOM);
         }
 #endif
-#ifdef VK_EXT_image_robustness
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
-            return sizeof(VkPhysicalDeviceImageRobustnessFeaturesEXT);
+#ifdef VK_EXT_image_compression_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceImageCompressionControlFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
+            return sizeof(VkImageCompressionControlEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
+            return sizeof(VkImageCompressionPropertiesEXT);
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT);
         }
 #endif
 #ifdef VK_EXT_4444_formats
@@ -3291,17 +4152,27 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPhysicalDevice4444FormatsFeaturesEXT);
         }
 #endif
+#ifdef VK_EXT_device_fault
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceFaultFeaturesEXT);
+        }
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT);
+        }
+#endif
 #ifdef VK_EXT_rgba10x6_formats
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
             return sizeof(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT);
         }
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
-            return sizeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE);
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT);
         }
-        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
-            return sizeof(VkMutableDescriptorTypeCreateInfoVALVE);
+        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: {
+            return sizeof(VkMutableDescriptorTypeCreateInfoEXT);
         }
 #endif
 #ifdef VK_EXT_vertex_input_dynamic_state
@@ -3314,6 +4185,22 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPhysicalDeviceDrmPropertiesEXT);
         }
 #endif
+#ifdef VK_EXT_device_address_binding_report
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceAddressBindingReportFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: {
+            return sizeof(VkDeviceAddressBindingCallbackDataEXT);
+        }
+#endif
+#ifdef VK_EXT_depth_clip_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceDepthClipControlFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: {
+            return sizeof(VkPipelineViewportDepthClipControlCreateInfoEXT);
+        }
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
             return sizeof(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT);
@@ -3356,6 +4243,22 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV);
         }
 #endif
+#ifdef VK_EXT_pipeline_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
+            return sizeof(VkPhysicalDevicePipelinePropertiesFeaturesEXT);
+        }
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: {
+            return sizeof(VkSubpassResolvePerformanceQueryEXT);
+        }
+        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: {
+            return sizeof(VkMultisampledRenderToSingleSampledInfoEXT);
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
             return sizeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT);
@@ -3369,6 +4272,11 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPipelineColorWriteCreateInfoEXT);
         }
 #endif
+#ifdef VK_EXT_primitives_generated_query
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
+            return sizeof(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT);
+        }
+#endif
 #ifdef VK_GOOGLE_gfxstream
         case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
             return sizeof(VkImportColorBufferGOOGLE);
@@ -3380,12 +4288,12 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkCreateBlobGOOGLE);
         }
 #endif
-#ifdef VK_EXT_global_priority_query
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
-            return sizeof(VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT);
+#ifdef VK_EXT_image_view_min_lod
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceImageViewMinLodFeaturesEXT);
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
-            return sizeof(VkQueueFamilyGlobalPriorityPropertiesEXT);
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: {
+            return sizeof(VkImageViewMinLodCreateInfoEXT);
         }
 #endif
 #ifdef VK_EXT_multi_draw
@@ -3396,6 +4304,55 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPhysicalDeviceMultiDrawPropertiesEXT);
         }
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT);
+        }
+#endif
+#ifdef VK_EXT_shader_tile_image
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceShaderTileImageFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceShaderTileImagePropertiesEXT);
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceOpacityMicromapFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceOpacityMicromapPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: {
+            return sizeof(VkAccelerationStructureTrianglesOpacityMicromapEXT);
+        }
+#endif
+#ifdef VK_NV_displacement_micromap
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
+            return sizeof(VkPhysicalDeviceDisplacementMicromapFeaturesNV);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: {
+            return sizeof(VkPhysicalDeviceDisplacementMicromapPropertiesNV);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: {
+            return sizeof(VkAccelerationStructureTrianglesDisplacementMicromapNV);
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
+            return sizeof(VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: {
+            return sizeof(VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI);
+        }
+#endif
 #ifdef VK_EXT_border_color_swizzle
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
             return sizeof(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT);
@@ -3409,6 +4366,204 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT);
         }
 #endif
+#ifdef VK_ARM_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: {
+            return sizeof(VkPhysicalDeviceShaderCorePropertiesARM);
+        }
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: {
+            return sizeof(VkImageViewSlicedCreateInfoEXT);
+        }
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
+            return sizeof(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE);
+        }
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceDepthClampZeroOneFeaturesEXT);
+        }
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT);
+        }
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: {
+            return sizeof(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: {
+            return sizeof(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM);
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: {
+            return sizeof(VkSubpassFragmentDensityMapOffsetEndInfoQCOM);
+        }
+#endif
+#ifdef VK_NV_copy_memory_indirect
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
+            return sizeof(VkPhysicalDeviceCopyMemoryIndirectFeaturesNV);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: {
+            return sizeof(VkPhysicalDeviceCopyMemoryIndirectPropertiesNV);
+        }
+#endif
+#ifdef VK_NV_memory_decompression
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: {
+            return sizeof(VkPhysicalDeviceMemoryDecompressionFeaturesNV);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: {
+            return sizeof(VkPhysicalDeviceMemoryDecompressionPropertiesNV);
+        }
+#endif
+#ifdef VK_NV_linear_color_attachment
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
+            return sizeof(VkPhysicalDeviceLinearColorAttachmentFeaturesNV);
+        }
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT);
+        }
+#endif
+#ifdef VK_QCOM_image_processing
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: {
+            return sizeof(VkImageViewSampleWeightCreateInfoQCOM);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
+            return sizeof(VkPhysicalDeviceImageProcessingFeaturesQCOM);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: {
+            return sizeof(VkPhysicalDeviceImageProcessingPropertiesQCOM);
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceExtendedDynamicState3FeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceExtendedDynamicState3PropertiesEXT);
+        }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: {
+            return sizeof(VkRenderPassCreationControlEXT);
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+            return sizeof(VkRenderPassCreationFeedbackCreateInfoEXT);
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: {
+            return sizeof(VkRenderPassSubpassFeedbackCreateInfoEXT);
+        }
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: {
+            return sizeof(VkDirectDriverLoadingListLUNARG);
+        }
+#endif
+#ifdef VK_EXT_shader_module_identifier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: {
+            return sizeof(VkPipelineShaderStageModuleIdentifierCreateInfoEXT);
+        }
+#endif
+#ifdef VK_NV_optical_flow
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
+            return sizeof(VkPhysicalDeviceOpticalFlowFeaturesNV);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: {
+            return sizeof(VkPhysicalDeviceOpticalFlowPropertiesNV);
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: {
+            return sizeof(VkOpticalFlowImageFormatInfoNV);
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: {
+            return sizeof(VkOpticalFlowSessionCreatePrivateDataInfoNV);
+        }
+#endif
+#ifdef VK_EXT_legacy_dithering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceLegacyDitheringFeaturesEXT);
+        }
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: {
+            return sizeof(VkPhysicalDevicePipelineProtectedAccessFeaturesEXT);
+        }
+#endif
+#ifdef VK_EXT_shader_object
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceShaderObjectFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceShaderObjectPropertiesEXT);
+        }
+#endif
+#ifdef VK_QCOM_tile_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
+            return sizeof(VkPhysicalDeviceTilePropertiesFeaturesQCOM);
+        }
+#endif
+#ifdef VK_SEC_amigo_profiling
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
+            return sizeof(VkPhysicalDeviceAmigoProfilingFeaturesSEC);
+        }
+        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: {
+            return sizeof(VkAmigoProfilingSubmitInfoSEC);
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
+            return sizeof(VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM);
+        }
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: {
+            return sizeof(VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
+            return sizeof(VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV);
+        }
+#endif
+#ifdef VK_ARM_shader_core_builtins
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
+            return sizeof(VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: {
+            return sizeof(VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM);
+        }
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
+            return sizeof(VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT);
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
+            return sizeof(VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM);
+        }
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: {
+            return sizeof(VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM);
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT);
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
             return sizeof(VkWriteDescriptorSetAccelerationStructureKHR);
@@ -3433,6 +4588,14 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
             return sizeof(VkPhysicalDeviceRayQueryFeaturesKHR);
         }
 #endif
+#ifdef VK_EXT_mesh_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
+            return sizeof(VkPhysicalDeviceMeshShaderFeaturesEXT);
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: {
+            return sizeof(VkPhysicalDeviceMeshShaderPropertiesEXT);
+        }
+#endif
         default: {
             return (size_t)0;
         }
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_extension_structs.h b/stream-servers/vulkan/cereal/common/goldfish_vk_extension_structs.h
index 92cfb38e..5859d93a 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_extension_structs.h
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_extension_structs.h
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_extension_structs
 //
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (header) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -52,6 +52,8 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_VERSION_1_2
 #endif
+#ifdef VK_VERSION_1_3
+#endif
 #ifdef VK_KHR_surface
 #endif
 #ifdef VK_KHR_swapchain
@@ -76,6 +78,8 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_KHR_video_decode_queue
 #endif
+#ifdef VK_KHR_video_decode_h264
+#endif
 #ifdef VK_KHR_dynamic_rendering
 #endif
 #ifdef VK_KHR_multiview
@@ -170,6 +174,10 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_KHR_shader_clock
 #endif
+#ifdef VK_KHR_video_decode_h265
+#endif
+#ifdef VK_KHR_global_priority
+#endif
 #ifdef VK_KHR_driver_properties
 #endif
 #ifdef VK_KHR_shader_float_controls
@@ -202,6 +210,8 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_KHR_pipeline_executable_properties
 #endif
+#ifdef VK_KHR_map_memory2
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -214,6 +224,8 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_KHR_synchronization2
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
@@ -224,8 +236,14 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_KHR_format_feature_flags2
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
 #endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+#endif
 #ifdef VK_ANDROID_native_buffer
 #endif
 #ifdef VK_EXT_debug_report
@@ -266,8 +284,6 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_EXT_video_encode_h265
 #endif
-#ifdef VK_EXT_video_decode_h264
-#endif
 #ifdef VK_AMD_texture_gather_bias_lod
 #endif
 #ifdef VK_AMD_shader_info
@@ -300,6 +316,8 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_EXT_astc_decode_mode
 #endif
+#ifdef VK_EXT_pipeline_robustness
+#endif
 #ifdef VK_EXT_conditional_rendering
 #endif
 #ifdef VK_NV_clip_space_w_scaling
@@ -338,8 +356,6 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_MVK_macos_surface
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -404,8 +420,6 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_AMD_shader_core_properties
 #endif
-#ifdef VK_EXT_video_decode_h265
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 #endif
 #ifdef VK_EXT_vertex_attribute_divisor
@@ -496,6 +510,10 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_EXT_shader_atomic_float2
 #endif
+#ifdef VK_EXT_surface_maintenance1
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+#endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -516,6 +534,8 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+#endif
 #ifdef VK_EXT_private_data
 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
@@ -524,6 +544,16 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+#endif
+#ifdef VK_EXT_metal_objects
+#endif
+#ifdef VK_EXT_descriptor_buffer
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
 #endif
 #ifdef VK_NV_ray_tracing_motion_blur
@@ -536,8 +566,16 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_EXT_image_robustness
 #endif
+#ifdef VK_EXT_image_compression_control
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+#endif
 #ifdef VK_EXT_4444_formats
 #endif
+#ifdef VK_EXT_device_fault
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 #endif
 #ifdef VK_NV_acquire_winrt_display
@@ -550,6 +588,10 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_EXT_physical_device_drm
 #endif
+#ifdef VK_EXT_device_address_binding_report
+#endif
+#ifdef VK_EXT_depth_clip_control
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 #endif
 #ifdef VK_FUCHSIA_external_memory
@@ -564,30 +606,110 @@ size_t goldfish_vk_extension_struct_size_with_stream_features(uint32_t streamFea
 #endif
 #ifdef VK_NV_external_memory_rdma
 #endif
+#ifdef VK_EXT_pipeline_properties
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 #endif
 #ifdef VK_QNX_screen_surface
 #endif
 #ifdef VK_EXT_color_write_enable
 #endif
+#ifdef VK_EXT_primitives_generated_query
+#endif
 #ifdef VK_GOOGLE_gfxstream
 #endif
 #ifdef VK_EXT_global_priority_query
 #endif
+#ifdef VK_EXT_image_view_min_lod
+#endif
 #ifdef VK_EXT_multi_draw
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+#endif
+#ifdef VK_EXT_shader_tile_image
+#endif
+#ifdef VK_EXT_opacity_micromap
+#endif
+#ifdef VK_NV_displacement_micromap
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+#endif
 #ifdef VK_EXT_border_color_swizzle
 #endif
 #ifdef VK_EXT_pageable_device_local_memory
 #endif
+#ifdef VK_ARM_shader_core_properties
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+#endif
+#ifdef VK_NV_copy_memory_indirect
+#endif
+#ifdef VK_NV_memory_decompression
+#endif
+#ifdef VK_NV_linear_color_attachment
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+#endif
+#ifdef VK_QCOM_image_processing
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+#endif
+#ifdef VK_EXT_shader_module_identifier
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+#endif
+#ifdef VK_EXT_legacy_dithering
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+#endif
+#ifdef VK_EXT_shader_object
+#endif
+#ifdef VK_QCOM_tile_properties
+#endif
+#ifdef VK_SEC_amigo_profiling
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+#endif
 #ifdef VK_KHR_acceleration_structure
 #endif
 #ifdef VK_KHR_ray_tracing_pipeline
 #endif
 #ifdef VK_KHR_ray_query
 #endif
+#ifdef VK_EXT_mesh_shader
+#endif
 
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_handlemap.cpp b/stream-servers/vulkan/cereal/common/goldfish_vk_handlemap.cpp
index e76c6f62..7d4afd0d 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_handlemap.cpp
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_handlemap.cpp
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_handlemap
 //
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (impl) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -2382,6 +2382,641 @@ void handlemap_VkDeviceMemoryOpaqueCaptureAddressInfo(
 }
 
 #endif
+#ifdef VK_VERSION_1_3
+void handlemap_VkPhysicalDeviceVulkan13Features(VulkanHandleMapping* handlemap,
+                                                VkPhysicalDeviceVulkan13Features* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceVulkan13Properties(VulkanHandleMapping* handlemap,
+                                                  VkPhysicalDeviceVulkan13Properties* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPipelineCreationFeedback(VulkanHandleMapping* handlemap,
+                                          VkPipelineCreationFeedback* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPipelineCreationFeedbackCreateInfo(VulkanHandleMapping* handlemap,
+                                                    VkPipelineCreationFeedbackCreateInfo* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pPipelineCreationFeedback) {
+        handlemap_VkPipelineCreationFeedback(
+            handlemap, (VkPipelineCreationFeedback*)(toMap->pPipelineCreationFeedback));
+    }
+    if (toMap) {
+        if (toMap->pPipelineStageCreationFeedbacks) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->pipelineStageCreationFeedbackCount; ++i) {
+                handlemap_VkPipelineCreationFeedback(
+                    handlemap,
+                    (VkPipelineCreationFeedback*)(toMap->pPipelineStageCreationFeedbacks + i));
+            }
+        }
+    }
+}
+
+void handlemap_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTerminateInvocationFeatures* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceToolProperties(VulkanHandleMapping* handlemap,
+                                              VkPhysicalDeviceToolProperties* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDevicePrivateDataFeatures(VulkanHandleMapping* handlemap,
+                                                   VkPhysicalDevicePrivateDataFeatures* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDevicePrivateDataCreateInfo(VulkanHandleMapping* handlemap,
+                                             VkDevicePrivateDataCreateInfo* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPrivateDataSlotCreateInfo(VulkanHandleMapping* handlemap,
+                                           VkPrivateDataSlotCreateInfo* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineCreationCacheControlFeatures* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMemoryBarrier2(VulkanHandleMapping* handlemap, VkMemoryBarrier2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkBufferMemoryBarrier2(VulkanHandleMapping* handlemap,
+                                      VkBufferMemoryBarrier2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkImageMemoryBarrier2(VulkanHandleMapping* handlemap, VkImageMemoryBarrier2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+    handlemap_VkImageSubresourceRange(handlemap,
+                                      (VkImageSubresourceRange*)(&toMap->subresourceRange));
+}
+
+void handlemap_VkDependencyInfo(VulkanHandleMapping* handlemap, VkDependencyInfo* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap) {
+        if (toMap->pMemoryBarriers) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->memoryBarrierCount; ++i) {
+                handlemap_VkMemoryBarrier2(handlemap,
+                                           (VkMemoryBarrier2*)(toMap->pMemoryBarriers + i));
+            }
+        }
+    }
+    if (toMap) {
+        if (toMap->pBufferMemoryBarriers) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->bufferMemoryBarrierCount; ++i) {
+                handlemap_VkBufferMemoryBarrier2(
+                    handlemap, (VkBufferMemoryBarrier2*)(toMap->pBufferMemoryBarriers + i));
+            }
+        }
+    }
+    if (toMap) {
+        if (toMap->pImageMemoryBarriers) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->imageMemoryBarrierCount; ++i) {
+                handlemap_VkImageMemoryBarrier2(
+                    handlemap, (VkImageMemoryBarrier2*)(toMap->pImageMemoryBarriers + i));
+            }
+        }
+    }
+}
+
+void handlemap_VkSemaphoreSubmitInfo(VulkanHandleMapping* handlemap, VkSemaphoreSubmitInfo* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
+}
+
+void handlemap_VkCommandBufferSubmitInfo(VulkanHandleMapping* handlemap,
+                                         VkCommandBufferSubmitInfo* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkCommandBuffer((VkCommandBuffer*)&toMap->commandBuffer);
+}
+
+void handlemap_VkSubmitInfo2(VulkanHandleMapping* handlemap, VkSubmitInfo2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap) {
+        if (toMap->pWaitSemaphoreInfos) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->waitSemaphoreInfoCount; ++i) {
+                handlemap_VkSemaphoreSubmitInfo(
+                    handlemap, (VkSemaphoreSubmitInfo*)(toMap->pWaitSemaphoreInfos + i));
+            }
+        }
+    }
+    if (toMap) {
+        if (toMap->pCommandBufferInfos) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->commandBufferInfoCount; ++i) {
+                handlemap_VkCommandBufferSubmitInfo(
+                    handlemap, (VkCommandBufferSubmitInfo*)(toMap->pCommandBufferInfos + i));
+            }
+        }
+    }
+    if (toMap) {
+        if (toMap->pSignalSemaphoreInfos) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->signalSemaphoreInfoCount; ++i) {
+                handlemap_VkSemaphoreSubmitInfo(
+                    handlemap, (VkSemaphoreSubmitInfo*)(toMap->pSignalSemaphoreInfos + i));
+            }
+        }
+    }
+}
+
+void handlemap_VkPhysicalDeviceSynchronization2Features(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceSynchronization2Features* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceImageRobustnessFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageRobustnessFeatures* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkBufferCopy2(VulkanHandleMapping* handlemap, VkBufferCopy2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkCopyBufferInfo2(VulkanHandleMapping* handlemap, VkCopyBufferInfo2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->srcBuffer);
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->dstBuffer);
+    if (toMap) {
+        if (toMap->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
+                handlemap_VkBufferCopy2(handlemap, (VkBufferCopy2*)(toMap->pRegions + i));
+            }
+        }
+    }
+}
+
+void handlemap_VkImageCopy2(VulkanHandleMapping* handlemap, VkImageCopy2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkImageSubresourceLayers(handlemap,
+                                       (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
+    handlemap_VkImageSubresourceLayers(handlemap,
+                                       (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
+}
+
+void handlemap_VkCopyImageInfo2(VulkanHandleMapping* handlemap, VkCopyImageInfo2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
+    if (toMap) {
+        if (toMap->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
+                handlemap_VkImageCopy2(handlemap, (VkImageCopy2*)(toMap->pRegions + i));
+            }
+        }
+    }
+}
+
+void handlemap_VkBufferImageCopy2(VulkanHandleMapping* handlemap, VkBufferImageCopy2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkImageSubresourceLayers(handlemap,
+                                       (VkImageSubresourceLayers*)(&toMap->imageSubresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->imageOffset));
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageExtent));
+}
+
+void handlemap_VkCopyBufferToImageInfo2(VulkanHandleMapping* handlemap,
+                                        VkCopyBufferToImageInfo2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->srcBuffer);
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
+    if (toMap) {
+        if (toMap->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
+                handlemap_VkBufferImageCopy2(handlemap, (VkBufferImageCopy2*)(toMap->pRegions + i));
+            }
+        }
+    }
+}
+
+void handlemap_VkCopyImageToBufferInfo2(VulkanHandleMapping* handlemap,
+                                        VkCopyImageToBufferInfo2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->dstBuffer);
+    if (toMap) {
+        if (toMap->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
+                handlemap_VkBufferImageCopy2(handlemap, (VkBufferImageCopy2*)(toMap->pRegions + i));
+            }
+        }
+    }
+}
+
+void handlemap_VkImageBlit2(VulkanHandleMapping* handlemap, VkImageBlit2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkImageSubresourceLayers(handlemap,
+                                       (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->srcOffsets + i));
+    }
+    handlemap_VkImageSubresourceLayers(handlemap,
+                                       (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->dstOffsets + i));
+    }
+}
+
+void handlemap_VkBlitImageInfo2(VulkanHandleMapping* handlemap, VkBlitImageInfo2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
+    if (toMap) {
+        if (toMap->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
+                handlemap_VkImageBlit2(handlemap, (VkImageBlit2*)(toMap->pRegions + i));
+            }
+        }
+    }
+}
+
+void handlemap_VkImageResolve2(VulkanHandleMapping* handlemap, VkImageResolve2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkImageSubresourceLayers(handlemap,
+                                       (VkImageSubresourceLayers*)(&toMap->srcSubresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
+    handlemap_VkImageSubresourceLayers(handlemap,
+                                       (VkImageSubresourceLayers*)(&toMap->dstSubresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
+}
+
+void handlemap_VkResolveImageInfo2(VulkanHandleMapping* handlemap, VkResolveImageInfo2* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
+    if (toMap) {
+        if (toMap->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
+                handlemap_VkImageResolve2(handlemap, (VkImageResolve2*)(toMap->pRegions + i));
+            }
+        }
+    }
+}
+
+void handlemap_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlFeatures* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceSubgroupSizeControlProperties(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlProperties* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    VulkanHandleMapping* handlemap, VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceInlineUniformBlockFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockFeatures* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceInlineUniformBlockProperties(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockProperties* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkWriteDescriptorSetInlineUniformBlock(
+    VulkanHandleMapping* handlemap, VkWriteDescriptorSetInlineUniformBlock* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    VulkanHandleMapping* handlemap, VkDescriptorPoolInlineUniformBlockCreateInfo* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceTextureCompressionASTCHDRFeatures* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkRenderingAttachmentInfo(VulkanHandleMapping* handlemap,
+                                         VkRenderingAttachmentInfo* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageView);
+    handlemap->mapHandles_VkImageView((VkImageView*)&toMap->resolveImageView);
+    handlemap_VkClearValue(handlemap, (VkClearValue*)(&toMap->clearValue));
+}
+
+void handlemap_VkRenderingInfo(VulkanHandleMapping* handlemap, VkRenderingInfo* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->renderArea));
+    if (toMap) {
+        if (toMap->pColorAttachments) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i) {
+                handlemap_VkRenderingAttachmentInfo(
+                    handlemap, (VkRenderingAttachmentInfo*)(toMap->pColorAttachments + i));
+            }
+        }
+    }
+    if (toMap->pDepthAttachment) {
+        handlemap_VkRenderingAttachmentInfo(handlemap,
+                                            (VkRenderingAttachmentInfo*)(toMap->pDepthAttachment));
+    }
+    if (toMap->pStencilAttachment) {
+        handlemap_VkRenderingAttachmentInfo(
+            handlemap, (VkRenderingAttachmentInfo*)(toMap->pStencilAttachment));
+    }
+}
+
+void handlemap_VkPipelineRenderingCreateInfo(VulkanHandleMapping* handlemap,
+                                             VkPipelineRenderingCreateInfo* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceDynamicRenderingFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDynamicRenderingFeatures* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkCommandBufferInheritanceRenderingInfo(
+    VulkanHandleMapping* handlemap, VkCommandBufferInheritanceRenderingInfo* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductFeatures* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductProperties* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceTexelBufferAlignmentProperties* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkFormatProperties3(VulkanHandleMapping* handlemap, VkFormatProperties3* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceMaintenance4Features(VulkanHandleMapping* handlemap,
+                                                    VkPhysicalDeviceMaintenance4Features* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceMaintenance4Properties(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance4Properties* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceBufferMemoryRequirements(VulkanHandleMapping* handlemap,
+                                                VkDeviceBufferMemoryRequirements* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pCreateInfo) {
+        handlemap_VkBufferCreateInfo(handlemap, (VkBufferCreateInfo*)(toMap->pCreateInfo));
+    }
+}
+
+void handlemap_VkDeviceImageMemoryRequirements(VulkanHandleMapping* handlemap,
+                                               VkDeviceImageMemoryRequirements* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pCreateInfo) {
+        handlemap_VkImageCreateInfo(handlemap, (VkImageCreateInfo*)(toMap->pCreateInfo));
+    }
+}
+
+#endif
 #ifdef VK_KHR_surface
 void handlemap_VkSurfaceCapabilitiesKHR(VulkanHandleMapping* handlemap,
                                         VkSurfaceCapabilitiesKHR* toMap) {
@@ -2628,8 +3263,17 @@ void handlemap_VkWin32SurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
 #endif
 #ifdef VK_KHR_video_queue
-void handlemap_VkVideoQueueFamilyProperties2KHR(VulkanHandleMapping* handlemap,
-                                                VkVideoQueueFamilyProperties2KHR* toMap) {
+void handlemap_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    VulkanHandleMapping* handlemap, VkQueueFamilyQueryResultStatusPropertiesKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkQueueFamilyVideoPropertiesKHR(VulkanHandleMapping* handlemap,
+                                               VkQueueFamilyVideoPropertiesKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -2637,7 +3281,7 @@ void handlemap_VkVideoQueueFamilyProperties2KHR(VulkanHandleMapping* handlemap,
     }
 }
 
-void handlemap_VkVideoProfileKHR(VulkanHandleMapping* handlemap, VkVideoProfileKHR* toMap) {
+void handlemap_VkVideoProfileInfoKHR(VulkanHandleMapping* handlemap, VkVideoProfileInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -2645,14 +3289,20 @@ void handlemap_VkVideoProfileKHR(VulkanHandleMapping* handlemap, VkVideoProfileK
     }
 }
 
-void handlemap_VkVideoProfilesKHR(VulkanHandleMapping* handlemap, VkVideoProfilesKHR* toMap) {
+void handlemap_VkVideoProfileListInfoKHR(VulkanHandleMapping* handlemap,
+                                         VkVideoProfileListInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    if (toMap->pProfiles) {
-        handlemap_VkVideoProfileKHR(handlemap, (VkVideoProfileKHR*)(toMap->pProfiles));
+    if (toMap) {
+        if (toMap->pProfiles) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->profileCount; ++i) {
+                handlemap_VkVideoProfileInfoKHR(handlemap,
+                                                (VkVideoProfileInfoKHR*)(toMap->pProfiles + i));
+            }
+        }
     }
 }
 
@@ -2663,9 +3313,10 @@ void handlemap_VkVideoCapabilitiesKHR(VulkanHandleMapping* handlemap,
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->videoPictureExtentGranularity));
-    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minExtent));
-    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxExtent));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->pictureAccessGranularity));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minCodedExtent));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxCodedExtent));
+    handlemap_VkExtensionProperties(handlemap, (VkExtensionProperties*)(&toMap->stdHeaderVersion));
 }
 
 void handlemap_VkPhysicalDeviceVideoFormatInfoKHR(VulkanHandleMapping* handlemap,
@@ -2675,9 +3326,6 @@ void handlemap_VkPhysicalDeviceVideoFormatInfoKHR(VulkanHandleMapping* handlemap
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    if (toMap->pVideoProfiles) {
-        handlemap_VkVideoProfilesKHR(handlemap, (VkVideoProfilesKHR*)(toMap->pVideoProfiles));
-    }
 }
 
 void handlemap_VkVideoFormatPropertiesKHR(VulkanHandleMapping* handlemap,
@@ -2687,10 +3335,11 @@ void handlemap_VkVideoFormatPropertiesKHR(VulkanHandleMapping* handlemap,
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
+    handlemap_VkComponentMapping(handlemap, (VkComponentMapping*)(&toMap->componentMapping));
 }
 
-void handlemap_VkVideoPictureResourceKHR(VulkanHandleMapping* handlemap,
-                                         VkVideoPictureResourceKHR* toMap) {
+void handlemap_VkVideoPictureResourceInfoKHR(VulkanHandleMapping* handlemap,
+                                             VkVideoPictureResourceInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -2701,33 +3350,31 @@ void handlemap_VkVideoPictureResourceKHR(VulkanHandleMapping* handlemap,
     handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageViewBinding);
 }
 
-void handlemap_VkVideoReferenceSlotKHR(VulkanHandleMapping* handlemap,
-                                       VkVideoReferenceSlotKHR* toMap) {
+void handlemap_VkVideoReferenceSlotInfoKHR(VulkanHandleMapping* handlemap,
+                                           VkVideoReferenceSlotInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
     if (toMap->pPictureResource) {
-        handlemap_VkVideoPictureResourceKHR(handlemap,
-                                            (VkVideoPictureResourceKHR*)(toMap->pPictureResource));
+        handlemap_VkVideoPictureResourceInfoKHR(
+            handlemap, (VkVideoPictureResourceInfoKHR*)(toMap->pPictureResource));
     }
 }
 
-void handlemap_VkVideoGetMemoryPropertiesKHR(VulkanHandleMapping* handlemap,
-                                             VkVideoGetMemoryPropertiesKHR* toMap) {
+void handlemap_VkVideoSessionMemoryRequirementsKHR(VulkanHandleMapping* handlemap,
+                                                   VkVideoSessionMemoryRequirementsKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    if (toMap->pMemoryRequirements) {
-        handlemap_VkMemoryRequirements2(handlemap,
-                                        (VkMemoryRequirements2*)(toMap->pMemoryRequirements));
-    }
+    handlemap_VkMemoryRequirements(handlemap, (VkMemoryRequirements*)(&toMap->memoryRequirements));
 }
 
-void handlemap_VkVideoBindMemoryKHR(VulkanHandleMapping* handlemap, VkVideoBindMemoryKHR* toMap) {
+void handlemap_VkBindVideoSessionMemoryInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkBindVideoSessionMemoryInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -2744,9 +3391,13 @@ void handlemap_VkVideoSessionCreateInfoKHR(VulkanHandleMapping* handlemap,
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
     if (toMap->pVideoProfile) {
-        handlemap_VkVideoProfileKHR(handlemap, (VkVideoProfileKHR*)(toMap->pVideoProfile));
+        handlemap_VkVideoProfileInfoKHR(handlemap, (VkVideoProfileInfoKHR*)(toMap->pVideoProfile));
     }
     handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxCodedExtent));
+    if (toMap->pStdHeaderVersion) {
+        handlemap_VkExtensionProperties(handlemap,
+                                        (VkExtensionProperties*)(toMap->pStdHeaderVersion));
+    }
 }
 
 void handlemap_VkVideoSessionParametersCreateInfoKHR(VulkanHandleMapping* handlemap,
@@ -2783,8 +3434,8 @@ void handlemap_VkVideoBeginCodingInfoKHR(VulkanHandleMapping* handlemap,
     if (toMap) {
         if (toMap->pReferenceSlots) {
             for (uint32_t i = 0; i < (uint32_t)toMap->referenceSlotCount; ++i) {
-                handlemap_VkVideoReferenceSlotKHR(
-                    handlemap, (VkVideoReferenceSlotKHR*)(toMap->pReferenceSlots + i));
+                handlemap_VkVideoReferenceSlotInfoKHR(
+                    handlemap, (VkVideoReferenceSlotInfoKHR*)(toMap->pReferenceSlots + i));
             }
         }
     }
@@ -2810,81 +3461,92 @@ void handlemap_VkVideoCodingControlInfoKHR(VulkanHandleMapping* handlemap,
 
 #endif
 #ifdef VK_KHR_video_decode_queue
+void handlemap_VkVideoDecodeCapabilitiesKHR(VulkanHandleMapping* handlemap,
+                                            VkVideoDecodeCapabilitiesKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkVideoDecodeUsageInfoKHR(VulkanHandleMapping* handlemap,
+                                         VkVideoDecodeUsageInfoKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
 void handlemap_VkVideoDecodeInfoKHR(VulkanHandleMapping* handlemap, VkVideoDecodeInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->codedOffset));
-    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->codedExtent));
     handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->srcBuffer);
-    handlemap_VkVideoPictureResourceKHR(handlemap,
-                                        (VkVideoPictureResourceKHR*)(&toMap->dstPictureResource));
+    handlemap_VkVideoPictureResourceInfoKHR(
+        handlemap, (VkVideoPictureResourceInfoKHR*)(&toMap->dstPictureResource));
     if (toMap->pSetupReferenceSlot) {
-        handlemap_VkVideoReferenceSlotKHR(handlemap,
-                                          (VkVideoReferenceSlotKHR*)(toMap->pSetupReferenceSlot));
+        handlemap_VkVideoReferenceSlotInfoKHR(
+            handlemap, (VkVideoReferenceSlotInfoKHR*)(toMap->pSetupReferenceSlot));
     }
     if (toMap) {
         if (toMap->pReferenceSlots) {
             for (uint32_t i = 0; i < (uint32_t)toMap->referenceSlotCount; ++i) {
-                handlemap_VkVideoReferenceSlotKHR(
-                    handlemap, (VkVideoReferenceSlotKHR*)(toMap->pReferenceSlots + i));
+                handlemap_VkVideoReferenceSlotInfoKHR(
+                    handlemap, (VkVideoReferenceSlotInfoKHR*)(toMap->pReferenceSlots + i));
             }
         }
     }
 }
 
 #endif
-#ifdef VK_KHR_dynamic_rendering
-void handlemap_VkRenderingAttachmentInfoKHR(VulkanHandleMapping* handlemap,
-                                            VkRenderingAttachmentInfoKHR* toMap) {
+#ifdef VK_KHR_video_decode_h264
+void handlemap_VkVideoDecodeH264ProfileInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkVideoDecodeH264ProfileInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageView);
-    handlemap->mapHandles_VkImageView((VkImageView*)&toMap->resolveImageView);
-    handlemap_VkClearValue(handlemap, (VkClearValue*)(&toMap->clearValue));
 }
 
-void handlemap_VkRenderingInfoKHR(VulkanHandleMapping* handlemap, VkRenderingInfoKHR* toMap) {
+void handlemap_VkVideoDecodeH264CapabilitiesKHR(VulkanHandleMapping* handlemap,
+                                                VkVideoDecodeH264CapabilitiesKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    handlemap_VkRect2D(handlemap, (VkRect2D*)(&toMap->renderArea));
-    if (toMap) {
-        if (toMap->pColorAttachments) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->colorAttachmentCount; ++i) {
-                handlemap_VkRenderingAttachmentInfoKHR(
-                    handlemap, (VkRenderingAttachmentInfoKHR*)(toMap->pColorAttachments + i));
-            }
-        }
-    }
-    if (toMap->pDepthAttachment) {
-        handlemap_VkRenderingAttachmentInfoKHR(
-            handlemap, (VkRenderingAttachmentInfoKHR*)(toMap->pDepthAttachment));
-    }
-    if (toMap->pStencilAttachment) {
-        handlemap_VkRenderingAttachmentInfoKHR(
-            handlemap, (VkRenderingAttachmentInfoKHR*)(toMap->pStencilAttachment));
+    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->fieldOffsetGranularity));
+}
+
+void handlemap_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersAddInfoKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
 }
 
-void handlemap_VkPipelineRenderingCreateInfoKHR(VulkanHandleMapping* handlemap,
-                                                VkPipelineRenderingCreateInfoKHR* toMap) {
+void handlemap_VkVideoDecodeH264SessionParametersCreateInfoKHR(
+    VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersCreateInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
+    if (toMap->pParametersAddInfo) {
+        handlemap_VkVideoDecodeH264SessionParametersAddInfoKHR(
+            handlemap, (VkVideoDecodeH264SessionParametersAddInfoKHR*)(toMap->pParametersAddInfo));
+    }
 }
 
-void handlemap_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceDynamicRenderingFeaturesKHR* toMap) {
+void handlemap_VkVideoDecodeH264PictureInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkVideoDecodeH264PictureInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -2892,8 +3554,8 @@ void handlemap_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
     }
 }
 
-void handlemap_VkCommandBufferInheritanceRenderingInfoKHR(
-    VulkanHandleMapping* handlemap, VkCommandBufferInheritanceRenderingInfoKHR* toMap) {
+void handlemap_VkVideoDecodeH264DpbSlotInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkVideoDecodeH264DpbSlotInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -2901,6 +3563,8 @@ void handlemap_VkCommandBufferInheritanceRenderingInfoKHR(
     }
 }
 
+#endif
+#ifdef VK_KHR_dynamic_rendering
 void handlemap_VkRenderingFragmentShadingRateAttachmentInfoKHR(
     VulkanHandleMapping* handlemap, VkRenderingFragmentShadingRateAttachmentInfoKHR* toMap) {
     (void)handlemap;
@@ -3452,6 +4116,95 @@ void handlemap_VkPhysicalDeviceShaderClockFeaturesKHR(
 }
 
 #endif
+#ifdef VK_KHR_video_decode_h265
+void handlemap_VkVideoDecodeH265ProfileInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkVideoDecodeH265ProfileInfoKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkVideoDecodeH265CapabilitiesKHR(VulkanHandleMapping* handlemap,
+                                                VkVideoDecodeH265CapabilitiesKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersAddInfoKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersCreateInfoKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pParametersAddInfo) {
+        handlemap_VkVideoDecodeH265SessionParametersAddInfoKHR(
+            handlemap, (VkVideoDecodeH265SessionParametersAddInfoKHR*)(toMap->pParametersAddInfo));
+    }
+}
+
+void handlemap_VkVideoDecodeH265PictureInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkVideoDecodeH265PictureInfoKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkVideoDecodeH265DpbSlotInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkVideoDecodeH265DpbSlotInfoKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_global_priority
+void handlemap_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    VulkanHandleMapping* handlemap, VkDeviceQueueGlobalPriorityCreateInfoKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    VulkanHandleMapping* handlemap, VkQueueFamilyGlobalPriorityPropertiesKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
 #ifdef VK_KHR_driver_properties
 #endif
 #ifdef VK_KHR_shader_float_controls
@@ -3465,15 +4218,6 @@ void handlemap_VkPhysicalDeviceShaderClockFeaturesKHR(
 #ifdef VK_KHR_vulkan_memory_model
 #endif
 #ifdef VK_KHR_shader_terminate_invocation
-void handlemap_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
 #endif
 #ifdef VK_KHR_fragment_shading_rate
 void handlemap_VkFragmentShadingRateAttachmentInfoKHR(
@@ -3632,26 +4376,28 @@ void handlemap_VkPipelineExecutableInternalRepresentationKHR(
 }
 
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-void handlemap_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toMap) {
+#ifdef VK_KHR_map_memory2
+void handlemap_VkMemoryMapInfoKHR(VulkanHandleMapping* handlemap, VkMemoryMapInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
+    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
 }
 
-void handlemap_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toMap) {
+void handlemap_VkMemoryUnmapInfoKHR(VulkanHandleMapping* handlemap, VkMemoryUnmapInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
+    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
 }
 
 #endif
+#ifdef VK_KHR_shader_integer_dot_product
+#endif
 #ifdef VK_KHR_pipeline_library
 void handlemap_VkPipelineLibraryCreateInfoKHR(VulkanHandleMapping* handlemap,
                                               VkPipelineLibraryCreateInfoKHR* toMap) {
@@ -3694,36 +4440,35 @@ void handlemap_VkVideoEncodeInfoKHR(VulkanHandleMapping* handlemap, VkVideoEncod
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->codedExtent));
-    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->dstBitstreamBuffer);
-    handlemap_VkVideoPictureResourceKHR(handlemap,
-                                        (VkVideoPictureResourceKHR*)(&toMap->srcPictureResource));
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->dstBuffer);
+    handlemap_VkVideoPictureResourceInfoKHR(
+        handlemap, (VkVideoPictureResourceInfoKHR*)(&toMap->srcPictureResource));
     if (toMap->pSetupReferenceSlot) {
-        handlemap_VkVideoReferenceSlotKHR(handlemap,
-                                          (VkVideoReferenceSlotKHR*)(toMap->pSetupReferenceSlot));
+        handlemap_VkVideoReferenceSlotInfoKHR(
+            handlemap, (VkVideoReferenceSlotInfoKHR*)(toMap->pSetupReferenceSlot));
     }
     if (toMap) {
         if (toMap->pReferenceSlots) {
             for (uint32_t i = 0; i < (uint32_t)toMap->referenceSlotCount; ++i) {
-                handlemap_VkVideoReferenceSlotKHR(
-                    handlemap, (VkVideoReferenceSlotKHR*)(toMap->pReferenceSlots + i));
+                handlemap_VkVideoReferenceSlotInfoKHR(
+                    handlemap, (VkVideoReferenceSlotInfoKHR*)(toMap->pReferenceSlots + i));
             }
         }
     }
 }
 
-void handlemap_VkVideoEncodeRateControlInfoKHR(VulkanHandleMapping* handlemap,
-                                               VkVideoEncodeRateControlInfoKHR* toMap) {
+void handlemap_VkVideoEncodeCapabilitiesKHR(VulkanHandleMapping* handlemap,
+                                            VkVideoEncodeCapabilitiesKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->inputImageDataFillAlignment));
 }
 
-#endif
-#ifdef VK_KHR_synchronization2
-void handlemap_VkMemoryBarrier2KHR(VulkanHandleMapping* handlemap, VkMemoryBarrier2KHR* toMap) {
+void handlemap_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    VulkanHandleMapping* handlemap, VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -3731,114 +4476,53 @@ void handlemap_VkMemoryBarrier2KHR(VulkanHandleMapping* handlemap, VkMemoryBarri
     }
 }
 
-void handlemap_VkBufferMemoryBarrier2KHR(VulkanHandleMapping* handlemap,
-                                         VkBufferMemoryBarrier2KHR* toMap) {
+void handlemap_VkVideoEncodeUsageInfoKHR(VulkanHandleMapping* handlemap,
+                                         VkVideoEncodeUsageInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
 }
 
-void handlemap_VkImageMemoryBarrier2KHR(VulkanHandleMapping* handlemap,
-                                        VkImageMemoryBarrier2KHR* toMap) {
+void handlemap_VkVideoEncodeRateControlLayerInfoKHR(VulkanHandleMapping* handlemap,
+                                                    VkVideoEncodeRateControlLayerInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
-    handlemap_VkImageSubresourceRange(handlemap,
-                                      (VkImageSubresourceRange*)(&toMap->subresourceRange));
 }
 
-void handlemap_VkDependencyInfoKHR(VulkanHandleMapping* handlemap, VkDependencyInfoKHR* toMap) {
+void handlemap_VkVideoEncodeRateControlInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkVideoEncodeRateControlInfoKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
     if (toMap) {
-        if (toMap->pMemoryBarriers) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->memoryBarrierCount; ++i) {
-                handlemap_VkMemoryBarrier2KHR(handlemap,
-                                              (VkMemoryBarrier2KHR*)(toMap->pMemoryBarriers + i));
-            }
-        }
-    }
-    if (toMap) {
-        if (toMap->pBufferMemoryBarriers) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->bufferMemoryBarrierCount; ++i) {
-                handlemap_VkBufferMemoryBarrier2KHR(
-                    handlemap, (VkBufferMemoryBarrier2KHR*)(toMap->pBufferMemoryBarriers + i));
-            }
-        }
-    }
-    if (toMap) {
-        if (toMap->pImageMemoryBarriers) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->imageMemoryBarrierCount; ++i) {
-                handlemap_VkImageMemoryBarrier2KHR(
-                    handlemap, (VkImageMemoryBarrier2KHR*)(toMap->pImageMemoryBarriers + i));
+        if (toMap->pLayers) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->layerCount; ++i) {
+                handlemap_VkVideoEncodeRateControlLayerInfoKHR(
+                    handlemap, (VkVideoEncodeRateControlLayerInfoKHR*)(toMap->pLayers + i));
             }
         }
     }
 }
 
-void handlemap_VkSemaphoreSubmitInfoKHR(VulkanHandleMapping* handlemap,
-                                        VkSemaphoreSubmitInfoKHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
-}
-
-void handlemap_VkCommandBufferSubmitInfoKHR(VulkanHandleMapping* handlemap,
-                                            VkCommandBufferSubmitInfoKHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap->mapHandles_VkCommandBuffer((VkCommandBuffer*)&toMap->commandBuffer);
-}
-
-void handlemap_VkSubmitInfo2KHR(VulkanHandleMapping* handlemap, VkSubmitInfo2KHR* toMap) {
+#endif
+#ifdef VK_KHR_synchronization2
+void handlemap_VkQueueFamilyCheckpointProperties2NV(VulkanHandleMapping* handlemap,
+                                                    VkQueueFamilyCheckpointProperties2NV* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    if (toMap) {
-        if (toMap->pWaitSemaphoreInfos) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->waitSemaphoreInfoCount; ++i) {
-                handlemap_VkSemaphoreSubmitInfoKHR(
-                    handlemap, (VkSemaphoreSubmitInfoKHR*)(toMap->pWaitSemaphoreInfos + i));
-            }
-        }
-    }
-    if (toMap) {
-        if (toMap->pCommandBufferInfos) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->commandBufferInfoCount; ++i) {
-                handlemap_VkCommandBufferSubmitInfoKHR(
-                    handlemap, (VkCommandBufferSubmitInfoKHR*)(toMap->pCommandBufferInfos + i));
-            }
-        }
-    }
-    if (toMap) {
-        if (toMap->pSignalSemaphoreInfos) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->signalSemaphoreInfoCount; ++i) {
-                handlemap_VkSemaphoreSubmitInfoKHR(
-                    handlemap, (VkSemaphoreSubmitInfoKHR*)(toMap->pSignalSemaphoreInfos + i));
-            }
-        }
-    }
 }
 
-void handlemap_VkPhysicalDeviceSynchronization2FeaturesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceSynchronization2FeaturesKHR* toMap) {
+void handlemap_VkCheckpointData2NV(VulkanHandleMapping* handlemap, VkCheckpointData2NV* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -3846,8 +4530,10 @@ void handlemap_VkPhysicalDeviceSynchronization2FeaturesKHR(
     }
 }
 
-void handlemap_VkQueueFamilyCheckpointProperties2NV(VulkanHandleMapping* handlemap,
-                                                    VkQueueFamilyCheckpointProperties2NV* toMap) {
+#endif
+#ifdef VK_KHR_fragment_shader_barycentric
+void handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -3855,7 +4541,8 @@ void handlemap_VkQueueFamilyCheckpointProperties2NV(VulkanHandleMapping* handlem
     }
 }
 
-void handlemap_VkCheckpointData2NV(VulkanHandleMapping* handlemap, VkCheckpointData2NV* toMap) {
+void handlemap_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -3877,16 +4564,6 @@ void handlemap_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
-void handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    VulkanHandleMapping* handlemap,
-    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
 #endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
 void handlemap_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
@@ -3901,196 +4578,33 @@ void handlemap_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_copy_commands2
-void handlemap_VkBufferCopy2KHR(VulkanHandleMapping* handlemap, VkBufferCopy2KHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
-void handlemap_VkCopyBufferInfo2KHR(VulkanHandleMapping* handlemap, VkCopyBufferInfo2KHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->srcBuffer);
-    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->dstBuffer);
-    if (toMap) {
-        if (toMap->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
-                handlemap_VkBufferCopy2KHR(handlemap, (VkBufferCopy2KHR*)(toMap->pRegions + i));
-            }
-        }
-    }
-}
-
-void handlemap_VkImageCopy2KHR(VulkanHandleMapping* handlemap, VkImageCopy2KHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap_VkImageSubresourceLayers(handlemap,
-                                       (VkImageSubresourceLayers*)(&toMap->srcSubresource));
-    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
-    handlemap_VkImageSubresourceLayers(handlemap,
-                                       (VkImageSubresourceLayers*)(&toMap->dstSubresource));
-    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
-    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
-}
-
-void handlemap_VkCopyImageInfo2KHR(VulkanHandleMapping* handlemap, VkCopyImageInfo2KHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
-    handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
-    if (toMap) {
-        if (toMap->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
-                handlemap_VkImageCopy2KHR(handlemap, (VkImageCopy2KHR*)(toMap->pRegions + i));
-            }
-        }
-    }
-}
-
-void handlemap_VkBufferImageCopy2KHR(VulkanHandleMapping* handlemap, VkBufferImageCopy2KHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap_VkImageSubresourceLayers(handlemap,
-                                       (VkImageSubresourceLayers*)(&toMap->imageSubresource));
-    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->imageOffset));
-    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageExtent));
-}
-
-void handlemap_VkCopyBufferToImageInfo2KHR(VulkanHandleMapping* handlemap,
-                                           VkCopyBufferToImageInfo2KHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->srcBuffer);
-    handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
-    if (toMap) {
-        if (toMap->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
-                handlemap_VkBufferImageCopy2KHR(handlemap,
-                                                (VkBufferImageCopy2KHR*)(toMap->pRegions + i));
-            }
-        }
-    }
-}
-
-void handlemap_VkCopyImageToBufferInfo2KHR(VulkanHandleMapping* handlemap,
-                                           VkCopyImageToBufferInfo2KHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
-    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->dstBuffer);
-    if (toMap) {
-        if (toMap->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
-                handlemap_VkBufferImageCopy2KHR(handlemap,
-                                                (VkBufferImageCopy2KHR*)(toMap->pRegions + i));
-            }
-        }
-    }
-}
-
-void handlemap_VkImageBlit2KHR(VulkanHandleMapping* handlemap, VkImageBlit2KHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap_VkImageSubresourceLayers(handlemap,
-                                       (VkImageSubresourceLayers*)(&toMap->srcSubresource));
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->srcOffsets + i));
-    }
-    handlemap_VkImageSubresourceLayers(handlemap,
-                                       (VkImageSubresourceLayers*)(&toMap->dstSubresource));
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        handlemap_VkOffset3D(handlemap, (VkOffset3D*)(toMap->dstOffsets + i));
-    }
-}
-
-void handlemap_VkBlitImageInfo2KHR(VulkanHandleMapping* handlemap, VkBlitImageInfo2KHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
-    handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
-    if (toMap) {
-        if (toMap->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
-                handlemap_VkImageBlit2KHR(handlemap, (VkImageBlit2KHR*)(toMap->pRegions + i));
-            }
-        }
-    }
-}
-
-void handlemap_VkImageResolve2KHR(VulkanHandleMapping* handlemap, VkImageResolve2KHR* toMap) {
+#endif
+#ifdef VK_KHR_format_feature_flags2
+#endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+void handlemap_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    handlemap_VkImageSubresourceLayers(handlemap,
-                                       (VkImageSubresourceLayers*)(&toMap->srcSubresource));
-    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->srcOffset));
-    handlemap_VkImageSubresourceLayers(handlemap,
-                                       (VkImageSubresourceLayers*)(&toMap->dstSubresource));
-    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->dstOffset));
-    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->extent));
 }
 
-void handlemap_VkResolveImageInfo2KHR(VulkanHandleMapping* handlemap,
-                                      VkResolveImageInfo2KHR* toMap) {
+void handlemap_VkTraceRaysIndirectCommand2KHR(VulkanHandleMapping* handlemap,
+                                              VkTraceRaysIndirectCommand2KHR* toMap) {
     (void)handlemap;
     (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap->mapHandles_VkImage((VkImage*)&toMap->srcImage);
-    handlemap->mapHandles_VkImage((VkImage*)&toMap->dstImage);
-    if (toMap) {
-        if (toMap->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
-                handlemap_VkImageResolve2KHR(handlemap, (VkImageResolve2KHR*)(toMap->pRegions + i));
-            }
-        }
-    }
 }
 
 #endif
-#ifdef VK_KHR_format_feature_flags2
-void handlemap_VkFormatProperties3KHR(VulkanHandleMapping* handlemap,
-                                      VkFormatProperties3KHR* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
+#ifdef VK_KHR_portability_enumeration
 #endif
 #ifdef VK_KHR_maintenance4
-void handlemap_VkPhysicalDeviceMaintenance4FeaturesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance4FeaturesKHR* toMap) {
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+void handlemap_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -4098,42 +4612,35 @@ void handlemap_VkPhysicalDeviceMaintenance4FeaturesKHR(
     }
 }
 
-void handlemap_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance4PropertiesKHR* toMap) {
+#endif
+#ifdef VK_ANDROID_native_buffer
+void handlemap_VkNativeBufferUsage2ANDROID(VulkanHandleMapping* handlemap,
+                                           VkNativeBufferUsage2ANDROID* toMap) {
     (void)handlemap;
     (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
 }
 
-void handlemap_VkDeviceBufferMemoryRequirementsKHR(VulkanHandleMapping* handlemap,
-                                                   VkDeviceBufferMemoryRequirementsKHR* toMap) {
+void handlemap_VkNativeBufferANDROID(VulkanHandleMapping* handlemap, VkNativeBufferANDROID* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    if (toMap->pCreateInfo) {
-        handlemap_VkBufferCreateInfo(handlemap, (VkBufferCreateInfo*)(toMap->pCreateInfo));
-    }
+    handlemap_VkNativeBufferUsage2ANDROID(handlemap,
+                                          (VkNativeBufferUsage2ANDROID*)(&toMap->usage2));
 }
 
-void handlemap_VkDeviceImageMemoryRequirementsKHR(VulkanHandleMapping* handlemap,
-                                                  VkDeviceImageMemoryRequirementsKHR* toMap) {
+void handlemap_VkSwapchainImageCreateInfoANDROID(VulkanHandleMapping* handlemap,
+                                                 VkSwapchainImageCreateInfoANDROID* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    if (toMap->pCreateInfo) {
-        handlemap_VkImageCreateInfo(handlemap, (VkImageCreateInfo*)(toMap->pCreateInfo));
-    }
 }
 
-#endif
-#ifdef VK_ANDROID_native_buffer
-void handlemap_VkNativeBufferANDROID(VulkanHandleMapping* handlemap, VkNativeBufferANDROID* toMap) {
+void handlemap_VkPhysicalDevicePresentationPropertiesANDROID(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePresentationPropertiesANDROID* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -4333,25 +4840,6 @@ void handlemap_VkVideoEncodeH264CapabilitiesEXT(VulkanHandleMapping* handlemap,
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minPictureSizeInMbs));
-    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxPictureSizeInMbs));
-    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->inputImageDataAlignment));
-    handlemap_VkExtensionProperties(handlemap,
-                                    (VkExtensionProperties*)(&toMap->stdExtensionVersion));
-}
-
-void handlemap_VkVideoEncodeH264SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
-                                                     VkVideoEncodeH264SessionCreateInfoEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxPictureSizeInMbs));
-    if (toMap->pStdExtensionVersion) {
-        handlemap_VkExtensionProperties(handlemap,
-                                        (VkExtensionProperties*)(toMap->pStdExtensionVersion));
-    }
 }
 
 void handlemap_VkVideoEncodeH264SessionParametersAddInfoEXT(
@@ -4376,8 +4864,8 @@ void handlemap_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     }
 }
 
-void handlemap_VkVideoEncodeH264DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
-                                               VkVideoEncodeH264DpbSlotInfoEXT* toMap) {
+void handlemap_VkVideoEncodeH264NaluSliceInfoEXT(VulkanHandleMapping* handlemap,
+                                                 VkVideoEncodeH264NaluSliceInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -4385,33 +4873,6 @@ void handlemap_VkVideoEncodeH264DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
     }
 }
 
-void handlemap_VkVideoEncodeH264NaluSliceEXT(VulkanHandleMapping* handlemap,
-                                             VkVideoEncodeH264NaluSliceEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    if (toMap) {
-        if (toMap->pRefFinalList0Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->refFinalList0EntryCount; ++i) {
-                handlemap_VkVideoEncodeH264DpbSlotInfoEXT(
-                    handlemap,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pRefFinalList0Entries + i));
-            }
-        }
-    }
-    if (toMap) {
-        if (toMap->pRefFinalList1Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->refFinalList1EntryCount; ++i) {
-                handlemap_VkVideoEncodeH264DpbSlotInfoEXT(
-                    handlemap,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pRefFinalList1Entries + i));
-            }
-        }
-    }
-}
-
 void handlemap_VkVideoEncodeH264VclFrameInfoEXT(VulkanHandleMapping* handlemap,
                                                 VkVideoEncodeH264VclFrameInfoEXT* toMap) {
     (void)handlemap;
@@ -4420,39 +4881,17 @@ void handlemap_VkVideoEncodeH264VclFrameInfoEXT(VulkanHandleMapping* handlemap,
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
     if (toMap) {
-        if (toMap->pRefDefaultFinalList0Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->refDefaultFinalList0EntryCount; ++i) {
-                handlemap_VkVideoEncodeH264DpbSlotInfoEXT(
-                    handlemap,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pRefDefaultFinalList0Entries + i));
-            }
-        }
-    }
-    if (toMap) {
-        if (toMap->pRefDefaultFinalList1Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->refDefaultFinalList1EntryCount; ++i) {
-                handlemap_VkVideoEncodeH264DpbSlotInfoEXT(
-                    handlemap,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pRefDefaultFinalList1Entries + i));
-            }
-        }
-    }
-    if (toMap) {
         if (toMap->pNaluSliceEntries) {
             for (uint32_t i = 0; i < (uint32_t)toMap->naluSliceEntryCount; ++i) {
-                handlemap_VkVideoEncodeH264NaluSliceEXT(
-                    handlemap, (VkVideoEncodeH264NaluSliceEXT*)(toMap->pNaluSliceEntries + i));
+                handlemap_VkVideoEncodeH264NaluSliceInfoEXT(
+                    handlemap, (VkVideoEncodeH264NaluSliceInfoEXT*)(toMap->pNaluSliceEntries + i));
             }
         }
     }
-    if (toMap->pCurrentPictureInfo) {
-        handlemap_VkVideoEncodeH264DpbSlotInfoEXT(
-            handlemap, (VkVideoEncodeH264DpbSlotInfoEXT*)(toMap->pCurrentPictureInfo));
-    }
 }
 
-void handlemap_VkVideoEncodeH264EmitPictureParametersEXT(
-    VulkanHandleMapping* handlemap, VkVideoEncodeH264EmitPictureParametersEXT* toMap) {
+void handlemap_VkVideoEncodeH264DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
+                                               VkVideoEncodeH264DpbSlotInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -4460,8 +4899,8 @@ void handlemap_VkVideoEncodeH264EmitPictureParametersEXT(
     }
 }
 
-void handlemap_VkVideoEncodeH264ProfileEXT(VulkanHandleMapping* handlemap,
-                                           VkVideoEncodeH264ProfileEXT* toMap) {
+void handlemap_VkVideoEncodeH264ProfileInfoEXT(VulkanHandleMapping* handlemap,
+                                               VkVideoEncodeH264ProfileInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -4469,57 +4908,54 @@ void handlemap_VkVideoEncodeH264ProfileEXT(VulkanHandleMapping* handlemap,
     }
 }
 
-#endif
-#ifdef VK_EXT_video_encode_h265
-void handlemap_VkVideoEncodeH265CapabilitiesEXT(VulkanHandleMapping* handlemap,
-                                                VkVideoEncodeH265CapabilitiesEXT* toMap) {
+void handlemap_VkVideoEncodeH264RateControlInfoEXT(VulkanHandleMapping* handlemap,
+                                                   VkVideoEncodeH264RateControlInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->inputImageDataAlignment));
-    handlemap_VkExtensionProperties(handlemap,
-                                    (VkExtensionProperties*)(&toMap->stdExtensionVersion));
 }
 
-void handlemap_VkVideoEncodeH265SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
-                                                     VkVideoEncodeH265SessionCreateInfoEXT* toMap) {
+void handlemap_VkVideoEncodeH264QpEXT(VulkanHandleMapping* handlemap,
+                                      VkVideoEncodeH264QpEXT* toMap) {
     (void)handlemap;
     (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    if (toMap->pStdExtensionVersion) {
-        handlemap_VkExtensionProperties(handlemap,
-                                        (VkExtensionProperties*)(toMap->pStdExtensionVersion));
-    }
 }
 
-void handlemap_VkVideoEncodeH265SessionParametersAddInfoEXT(
-    VulkanHandleMapping* handlemap, VkVideoEncodeH265SessionParametersAddInfoEXT* toMap) {
+void handlemap_VkVideoEncodeH264FrameSizeEXT(VulkanHandleMapping* handlemap,
+                                             VkVideoEncodeH264FrameSizeEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkVideoEncodeH264RateControlLayerInfoEXT(
+    VulkanHandleMapping* handlemap, VkVideoEncodeH264RateControlLayerInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
+    handlemap_VkVideoEncodeH264QpEXT(handlemap, (VkVideoEncodeH264QpEXT*)(&toMap->initialRcQp));
+    handlemap_VkVideoEncodeH264QpEXT(handlemap, (VkVideoEncodeH264QpEXT*)(&toMap->minQp));
+    handlemap_VkVideoEncodeH264QpEXT(handlemap, (VkVideoEncodeH264QpEXT*)(&toMap->maxQp));
+    handlemap_VkVideoEncodeH264FrameSizeEXT(handlemap,
+                                            (VkVideoEncodeH264FrameSizeEXT*)(&toMap->maxFrameSize));
 }
 
-void handlemap_VkVideoEncodeH265SessionParametersCreateInfoEXT(
-    VulkanHandleMapping* handlemap, VkVideoEncodeH265SessionParametersCreateInfoEXT* toMap) {
+#endif
+#ifdef VK_EXT_video_encode_h265
+void handlemap_VkVideoEncodeH265CapabilitiesEXT(VulkanHandleMapping* handlemap,
+                                                VkVideoEncodeH265CapabilitiesEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    if (toMap->pParametersAddInfo) {
-        handlemap_VkVideoEncodeH265SessionParametersAddInfoEXT(
-            handlemap, (VkVideoEncodeH265SessionParametersAddInfoEXT*)(toMap->pParametersAddInfo));
-    }
 }
 
-void handlemap_VkVideoEncodeH265DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
-                                               VkVideoEncodeH265DpbSlotInfoEXT* toMap) {
+void handlemap_VkVideoEncodeH265SessionParametersAddInfoEXT(
+    VulkanHandleMapping* handlemap, VkVideoEncodeH265SessionParametersAddInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -4527,44 +4963,26 @@ void handlemap_VkVideoEncodeH265DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
     }
 }
 
-void handlemap_VkVideoEncodeH265ReferenceListsEXT(VulkanHandleMapping* handlemap,
-                                                  VkVideoEncodeH265ReferenceListsEXT* toMap) {
+void handlemap_VkVideoEncodeH265SessionParametersCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkVideoEncodeH265SessionParametersCreateInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    if (toMap) {
-        if (toMap->pReferenceList0Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->referenceList0EntryCount; ++i) {
-                handlemap_VkVideoEncodeH265DpbSlotInfoEXT(
-                    handlemap,
-                    (VkVideoEncodeH265DpbSlotInfoEXT*)(toMap->pReferenceList0Entries + i));
-            }
-        }
-    }
-    if (toMap) {
-        if (toMap->pReferenceList1Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->referenceList1EntryCount; ++i) {
-                handlemap_VkVideoEncodeH265DpbSlotInfoEXT(
-                    handlemap,
-                    (VkVideoEncodeH265DpbSlotInfoEXT*)(toMap->pReferenceList1Entries + i));
-            }
-        }
+    if (toMap->pParametersAddInfo) {
+        handlemap_VkVideoEncodeH265SessionParametersAddInfoEXT(
+            handlemap, (VkVideoEncodeH265SessionParametersAddInfoEXT*)(toMap->pParametersAddInfo));
     }
 }
 
-void handlemap_VkVideoEncodeH265NaluSliceEXT(VulkanHandleMapping* handlemap,
-                                             VkVideoEncodeH265NaluSliceEXT* toMap) {
+void handlemap_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+    VulkanHandleMapping* handlemap, VkVideoEncodeH265NaluSliceSegmentInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    if (toMap->pReferenceFinalLists) {
-        handlemap_VkVideoEncodeH265ReferenceListsEXT(
-            handlemap, (VkVideoEncodeH265ReferenceListsEXT*)(toMap->pReferenceFinalLists));
-    }
 }
 
 void handlemap_VkVideoEncodeH265VclFrameInfoEXT(VulkanHandleMapping* handlemap,
@@ -4574,76 +4992,29 @@ void handlemap_VkVideoEncodeH265VclFrameInfoEXT(VulkanHandleMapping* handlemap,
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    if (toMap->pReferenceFinalLists) {
-        handlemap_VkVideoEncodeH265ReferenceListsEXT(
-            handlemap, (VkVideoEncodeH265ReferenceListsEXT*)(toMap->pReferenceFinalLists));
-    }
     if (toMap) {
-        if (toMap->pNaluSliceEntries) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->naluSliceEntryCount; ++i) {
-                handlemap_VkVideoEncodeH265NaluSliceEXT(
-                    handlemap, (VkVideoEncodeH265NaluSliceEXT*)(toMap->pNaluSliceEntries + i));
+        if (toMap->pNaluSliceSegmentEntries) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->naluSliceSegmentEntryCount; ++i) {
+                handlemap_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+                    handlemap,
+                    (VkVideoEncodeH265NaluSliceSegmentInfoEXT*)(toMap->pNaluSliceSegmentEntries +
+                                                                i));
             }
         }
     }
 }
 
-void handlemap_VkVideoEncodeH265EmitPictureParametersEXT(
-    VulkanHandleMapping* handlemap, VkVideoEncodeH265EmitPictureParametersEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
-void handlemap_VkVideoEncodeH265ProfileEXT(VulkanHandleMapping* handlemap,
-                                           VkVideoEncodeH265ProfileEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
-#endif
-#ifdef VK_EXT_video_decode_h264
-void handlemap_VkVideoDecodeH264ProfileEXT(VulkanHandleMapping* handlemap,
-                                           VkVideoDecodeH264ProfileEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
-void handlemap_VkVideoDecodeH264CapabilitiesEXT(VulkanHandleMapping* handlemap,
-                                                VkVideoDecodeH264CapabilitiesEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->fieldOffsetGranularity));
-    handlemap_VkExtensionProperties(handlemap,
-                                    (VkExtensionProperties*)(&toMap->stdExtensionVersion));
-}
-
-void handlemap_VkVideoDecodeH264SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
-                                                     VkVideoDecodeH264SessionCreateInfoEXT* toMap) {
+void handlemap_VkVideoEncodeH265DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
+                                               VkVideoEncodeH265DpbSlotInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    if (toMap->pStdExtensionVersion) {
-        handlemap_VkExtensionProperties(handlemap,
-                                        (VkExtensionProperties*)(toMap->pStdExtensionVersion));
-    }
 }
 
-void handlemap_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersAddInfoEXT* toMap) {
+void handlemap_VkVideoEncodeH265ProfileInfoEXT(VulkanHandleMapping* handlemap,
+                                               VkVideoEncodeH265ProfileInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -4651,44 +5022,39 @@ void handlemap_VkVideoDecodeH264SessionParametersAddInfoEXT(
     }
 }
 
-void handlemap_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-    VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersCreateInfoEXT* toMap) {
+void handlemap_VkVideoEncodeH265RateControlInfoEXT(VulkanHandleMapping* handlemap,
+                                                   VkVideoEncodeH265RateControlInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
-    if (toMap->pParametersAddInfo) {
-        handlemap_VkVideoDecodeH264SessionParametersAddInfoEXT(
-            handlemap, (VkVideoDecodeH264SessionParametersAddInfoEXT*)(toMap->pParametersAddInfo));
-    }
 }
 
-void handlemap_VkVideoDecodeH264PictureInfoEXT(VulkanHandleMapping* handlemap,
-                                               VkVideoDecodeH264PictureInfoEXT* toMap) {
+void handlemap_VkVideoEncodeH265QpEXT(VulkanHandleMapping* handlemap,
+                                      VkVideoEncodeH265QpEXT* toMap) {
     (void)handlemap;
     (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
 }
 
-void handlemap_VkVideoDecodeH264MvcEXT(VulkanHandleMapping* handlemap,
-                                       VkVideoDecodeH264MvcEXT* toMap) {
+void handlemap_VkVideoEncodeH265FrameSizeEXT(VulkanHandleMapping* handlemap,
+                                             VkVideoEncodeH265FrameSizeEXT* toMap) {
     (void)handlemap;
     (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
 }
 
-void handlemap_VkVideoDecodeH264DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
-                                               VkVideoDecodeH264DpbSlotInfoEXT* toMap) {
+void handlemap_VkVideoEncodeH265RateControlLayerInfoEXT(
+    VulkanHandleMapping* handlemap, VkVideoEncodeH265RateControlLayerInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
+    handlemap_VkVideoEncodeH265QpEXT(handlemap, (VkVideoEncodeH265QpEXT*)(&toMap->initialRcQp));
+    handlemap_VkVideoEncodeH265QpEXT(handlemap, (VkVideoEncodeH265QpEXT*)(&toMap->minQp));
+    handlemap_VkVideoEncodeH265QpEXT(handlemap, (VkVideoEncodeH265QpEXT*)(&toMap->maxQp));
+    handlemap_VkVideoEncodeH265FrameSizeEXT(handlemap,
+                                            (VkVideoEncodeH265FrameSizeEXT*)(&toMap->maxFrameSize));
 }
 
 #endif
@@ -4840,8 +5206,19 @@ void handlemap_VkViSurfaceCreateInfoNN(VulkanHandleMapping* handlemap,
 #ifdef VK_EXT_shader_subgroup_vote
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
-void handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toMap) {
+#endif
+#ifdef VK_EXT_astc_decode_mode
+void handlemap_VkImageViewASTCDecodeModeEXT(VulkanHandleMapping* handlemap,
+                                            VkImageViewASTCDecodeModeEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceASTCDecodeFeaturesEXT(VulkanHandleMapping* handlemap,
+                                                     VkPhysicalDeviceASTCDecodeFeaturesEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -4850,9 +5227,9 @@ void handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
 }
 
 #endif
-#ifdef VK_EXT_astc_decode_mode
-void handlemap_VkImageViewASTCDecodeModeEXT(VulkanHandleMapping* handlemap,
-                                            VkImageViewASTCDecodeModeEXT* toMap) {
+#ifdef VK_EXT_pipeline_robustness
+void handlemap_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineRobustnessFeaturesEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -4860,8 +5237,17 @@ void handlemap_VkImageViewASTCDecodeModeEXT(VulkanHandleMapping* handlemap,
     }
 }
 
-void handlemap_VkPhysicalDeviceASTCDecodeFeaturesEXT(VulkanHandleMapping* handlemap,
-                                                     VkPhysicalDeviceASTCDecodeFeaturesEXT* toMap) {
+void handlemap_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineRobustnessPropertiesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPipelineRobustnessCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                                 VkPipelineRobustnessCreateInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -5164,8 +5550,6 @@ void handlemap_VkMacOSSurfaceCreateInfoMVK(VulkanHandleMapping* handlemap,
 }
 
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -5319,42 +5703,6 @@ void handlemap_VkAndroidHardwareBufferFormatProperties2ANDROID(
 #ifdef VK_AMD_shader_fragment_mask
 #endif
 #ifdef VK_EXT_inline_uniform_block
-void handlemap_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
-void handlemap_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
-void handlemap_VkWriteDescriptorSetInlineUniformBlockEXT(
-    VulkanHandleMapping* handlemap, VkWriteDescriptorSetInlineUniformBlockEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
-void handlemap_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    VulkanHandleMapping* handlemap, VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
 #endif
 #ifdef VK_EXT_shader_stencil_export
 #endif
@@ -5940,15 +6288,6 @@ void handlemap_VkFilterCubicImageViewImageFormatPropertiesEXT(
 #ifdef VK_QCOM_render_pass_shader_resolve
 #endif
 #ifdef VK_EXT_global_priority
-void handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    VulkanHandleMapping* handlemap, VkDeviceQueueGlobalPriorityCreateInfoEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
 #endif
 #ifdef VK_EXT_external_memory_host
 void handlemap_VkImportMemoryHostPointerInfoEXT(VulkanHandleMapping* handlemap,
@@ -6014,81 +6353,6 @@ void handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(
 }
 
 #endif
-#ifdef VK_EXT_video_decode_h265
-void handlemap_VkVideoDecodeH265ProfileEXT(VulkanHandleMapping* handlemap,
-                                           VkVideoDecodeH265ProfileEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
-void handlemap_VkVideoDecodeH265CapabilitiesEXT(VulkanHandleMapping* handlemap,
-                                                VkVideoDecodeH265CapabilitiesEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    handlemap_VkExtensionProperties(handlemap,
-                                    (VkExtensionProperties*)(&toMap->stdExtensionVersion));
-}
-
-void handlemap_VkVideoDecodeH265SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
-                                                     VkVideoDecodeH265SessionCreateInfoEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    if (toMap->pStdExtensionVersion) {
-        handlemap_VkExtensionProperties(handlemap,
-                                        (VkExtensionProperties*)(toMap->pStdExtensionVersion));
-    }
-}
-
-void handlemap_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersAddInfoEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
-void handlemap_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersCreateInfoEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    if (toMap->pParametersAddInfo) {
-        handlemap_VkVideoDecodeH265SessionParametersAddInfoEXT(
-            handlemap, (VkVideoDecodeH265SessionParametersAddInfoEXT*)(toMap->pParametersAddInfo));
-    }
-}
-
-void handlemap_VkVideoDecodeH265PictureInfoEXT(VulkanHandleMapping* handlemap,
-                                               VkVideoDecodeH265PictureInfoEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
-void handlemap_VkVideoDecodeH265DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
-                                               VkVideoDecodeH265DpbSlotInfoEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 void handlemap_VkDeviceMemoryOverallocationCreateInfoAMD(
     VulkanHandleMapping* handlemap, VkDeviceMemoryOverallocationCreateInfoAMD* toMap) {
@@ -6157,34 +6421,6 @@ void handlemap_VkPresentFrameTokenGGP(VulkanHandleMapping* handlemap,
 
 #endif
 #ifdef VK_EXT_pipeline_creation_feedback
-void handlemap_VkPipelineCreationFeedbackEXT(VulkanHandleMapping* handlemap,
-                                             VkPipelineCreationFeedbackEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-}
-
-void handlemap_VkPipelineCreationFeedbackCreateInfoEXT(
-    VulkanHandleMapping* handlemap, VkPipelineCreationFeedbackCreateInfoEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-    if (toMap->pPipelineCreationFeedback) {
-        handlemap_VkPipelineCreationFeedbackEXT(
-            handlemap, (VkPipelineCreationFeedbackEXT*)(toMap->pPipelineCreationFeedback));
-    }
-    if (toMap) {
-        if (toMap->pPipelineStageCreationFeedbacks) {
-            for (uint32_t i = 0; i < (uint32_t)toMap->pipelineStageCreationFeedbackCount; ++i) {
-                handlemap_VkPipelineCreationFeedbackEXT(
-                    handlemap,
-                    (VkPipelineCreationFeedbackEXT*)(toMap->pPipelineStageCreationFeedbacks + i));
-            }
-        }
-    }
-}
-
 #endif
 #ifdef VK_NV_shader_subgroup_partitioned
 #endif
@@ -6226,15 +6462,6 @@ void handlemap_VkDrawMeshTasksIndirectCommandNV(VulkanHandleMapping* handlemap,
 
 #endif
 #ifdef VK_NV_fragment_shader_barycentric
-void handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
 #endif
 #ifdef VK_NV_shader_image_footprint
 void handlemap_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -6466,33 +6693,6 @@ void handlemap_VkRenderPassFragmentDensityMapCreateInfoEXT(
 #ifdef VK_GOOGLE_decorate_string
 #endif
 #ifdef VK_EXT_subgroup_size_control
-void handlemap_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
-void handlemap_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
-void handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    VulkanHandleMapping* handlemap, VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
 #endif
 #ifdef VK_AMD_shader_core_properties2
 void handlemap_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -6591,15 +6791,6 @@ void handlemap_VkBufferDeviceAddressCreateInfoEXT(VulkanHandleMapping* handlemap
 
 #endif
 #ifdef VK_EXT_tooling_info
-void handlemap_VkPhysicalDeviceToolPropertiesEXT(VulkanHandleMapping* handlemap,
-                                                 VkPhysicalDeviceToolPropertiesEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
 #endif
 #ifdef VK_EXT_separate_stencil_usage
 #endif
@@ -6839,10 +7030,70 @@ void handlemap_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
 }
 
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-void handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
-    VulkanHandleMapping* handlemap,
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toMap) {
+#ifdef VK_EXT_surface_maintenance1
+void handlemap_VkSurfacePresentModeEXT(VulkanHandleMapping* handlemap,
+                                       VkSurfacePresentModeEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkSurfacePresentScalingCapabilitiesEXT(
+    VulkanHandleMapping* handlemap, VkSurfacePresentScalingCapabilitiesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->minScaledImageExtent));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxScaledImageExtent));
+}
+
+void handlemap_VkSurfacePresentModeCompatibilityEXT(VulkanHandleMapping* handlemap,
+                                                    VkSurfacePresentModeCompatibilityEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+void handlemap_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkSwapchainPresentFenceInfoEXT(VulkanHandleMapping* handlemap,
+                                              VkSwapchainPresentFenceInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pFences) {
+        handlemap->mapHandles_VkFence((VkFence*)toMap->pFences, toMap->swapchainCount);
+    }
+}
+
+void handlemap_VkSwapchainPresentModesCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                                    VkSwapchainPresentModesCreateInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkSwapchainPresentModeInfoEXT(VulkanHandleMapping* handlemap,
+                                             VkSwapchainPresentModeInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -6850,6 +7101,27 @@ void handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
     }
 }
 
+void handlemap_VkSwapchainPresentScalingCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkSwapchainPresentScalingCreateInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkReleaseSwapchainImagesInfoEXT(VulkanHandleMapping* handlemap,
+                                               VkReleaseSwapchainImagesInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSwapchainKHR((VkSwapchainKHR*)&toMap->swapchain);
+}
+
+#endif
+#ifdef VK_EXT_shader_demote_to_helper_invocation
 #endif
 #ifdef VK_NV_device_generated_commands
 void handlemap_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
@@ -7042,15 +7314,6 @@ void handlemap_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
     }
 }
 
-void handlemap_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toMap) {
-    (void)handlemap;
-    (void)toMap;
-    if (toMap->pNext) {
-        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
-    }
-}
-
 #endif
 #ifdef VK_QCOM_render_pass_transform
 void handlemap_VkRenderPassTransformBeginInfoQCOM(VulkanHandleMapping* handlemap,
@@ -7156,9 +7419,9 @@ void handlemap_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
-#ifdef VK_EXT_private_data
-void handlemap_VkPhysicalDevicePrivateDataFeaturesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDevicePrivateDataFeaturesEXT* toMap) {
+#ifdef VK_NV_present_barrier
+void handlemap_VkPhysicalDevicePresentBarrierFeaturesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePresentBarrierFeaturesNV* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -7166,8 +7429,8 @@ void handlemap_VkPhysicalDevicePrivateDataFeaturesEXT(
     }
 }
 
-void handlemap_VkDevicePrivateDataCreateInfoEXT(VulkanHandleMapping* handlemap,
-                                                VkDevicePrivateDataCreateInfoEXT* toMap) {
+void handlemap_VkSurfaceCapabilitiesPresentBarrierNV(VulkanHandleMapping* handlemap,
+                                                     VkSurfaceCapabilitiesPresentBarrierNV* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -7175,8 +7438,8 @@ void handlemap_VkDevicePrivateDataCreateInfoEXT(VulkanHandleMapping* handlemap,
     }
 }
 
-void handlemap_VkPrivateDataSlotCreateInfoEXT(VulkanHandleMapping* handlemap,
-                                              VkPrivateDataSlotCreateInfoEXT* toMap) {
+void handlemap_VkSwapchainPresentBarrierCreateInfoNV(VulkanHandleMapping* handlemap,
+                                                     VkSwapchainPresentBarrierCreateInfoNV* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -7185,21 +7448,332 @@ void handlemap_VkPrivateDataSlotCreateInfoEXT(VulkanHandleMapping* handlemap,
 }
 
 #endif
+#ifdef VK_EXT_private_data
+#endif
 #ifdef VK_EXT_pipeline_creation_cache_control
-void handlemap_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+#endif
+#ifdef VK_NV_device_diagnostics_config
+void handlemap_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceDiagnosticsConfigCreateInfoNV(VulkanHandleMapping* handlemap,
+                                                     VkDeviceDiagnosticsConfigCreateInfoNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_render_pass_store_ops
+#endif
+#ifdef VK_NV_low_latency
+void handlemap_VkQueryLowLatencySupportNV(VulkanHandleMapping* handlemap,
+                                          VkQueryLowLatencySupportNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_metal_objects
+void handlemap_VkExportMetalObjectCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                                VkExportMetalObjectCreateInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExportMetalObjectsInfoEXT(VulkanHandleMapping* handlemap,
+                                           VkExportMetalObjectsInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExportMetalDeviceInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkExportMetalDeviceInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExportMetalCommandQueueInfoEXT(VulkanHandleMapping* handlemap,
+                                                VkExportMetalCommandQueueInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkQueue((VkQueue*)&toMap->queue);
+}
+
+void handlemap_VkExportMetalBufferInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkExportMetalBufferInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkDeviceMemory((VkDeviceMemory*)&toMap->memory);
+}
+
+void handlemap_VkImportMetalBufferInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkImportMetalBufferInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExportMetalTextureInfoEXT(VulkanHandleMapping* handlemap,
+                                           VkExportMetalTextureInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+    handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageView);
+    handlemap->mapHandles_VkBufferView((VkBufferView*)&toMap->bufferView);
+}
+
+void handlemap_VkImportMetalTextureInfoEXT(VulkanHandleMapping* handlemap,
+                                           VkImportMetalTextureInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExportMetalIOSurfaceInfoEXT(VulkanHandleMapping* handlemap,
+                                             VkExportMetalIOSurfaceInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+}
+
+void handlemap_VkImportMetalIOSurfaceInfoEXT(VulkanHandleMapping* handlemap,
+                                             VkImportMetalIOSurfaceInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkExportMetalSharedEventInfoEXT(VulkanHandleMapping* handlemap,
+                                               VkExportMetalSharedEventInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSemaphore((VkSemaphore*)&toMap->semaphore);
+    handlemap->mapHandles_VkEvent((VkEvent*)&toMap->event);
+}
+
+void handlemap_VkImportMetalSharedEventInfoEXT(VulkanHandleMapping* handlemap,
+                                               VkImportMetalSharedEventInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void handlemap_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorBufferPropertiesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
     VulkanHandleMapping* handlemap,
-    VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toMap) {
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorBufferFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDescriptorAddressInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkDescriptorAddressInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDescriptorBufferBindingInfoEXT(VulkanHandleMapping* handlemap,
+                                                VkDescriptorBufferBindingInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    VulkanHandleMapping* handlemap, VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkDescriptorDataEXT(VulkanHandleMapping* handlemap, VkDescriptorDataEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pSampler) {
+        handlemap->mapHandles_VkSampler((VkSampler*)toMap->pSampler, 1);
+    }
+    if (toMap->pCombinedImageSampler) {
+        handlemap_VkDescriptorImageInfo(handlemap,
+                                        (VkDescriptorImageInfo*)(toMap->pCombinedImageSampler));
+    }
+    if (toMap->pInputAttachmentImage) {
+        handlemap_VkDescriptorImageInfo(handlemap,
+                                        (VkDescriptorImageInfo*)(toMap->pInputAttachmentImage));
+    }
+    if (toMap->pSampledImage) {
+        handlemap_VkDescriptorImageInfo(handlemap, (VkDescriptorImageInfo*)(toMap->pSampledImage));
+    }
+    if (toMap->pStorageImage) {
+        handlemap_VkDescriptorImageInfo(handlemap, (VkDescriptorImageInfo*)(toMap->pStorageImage));
+    }
+    if (toMap->pUniformTexelBuffer) {
+        handlemap_VkDescriptorAddressInfoEXT(
+            handlemap, (VkDescriptorAddressInfoEXT*)(toMap->pUniformTexelBuffer));
+    }
+    if (toMap->pStorageTexelBuffer) {
+        handlemap_VkDescriptorAddressInfoEXT(
+            handlemap, (VkDescriptorAddressInfoEXT*)(toMap->pStorageTexelBuffer));
+    }
+    if (toMap->pUniformBuffer) {
+        handlemap_VkDescriptorAddressInfoEXT(handlemap,
+                                             (VkDescriptorAddressInfoEXT*)(toMap->pUniformBuffer));
+    }
+    if (toMap->pStorageBuffer) {
+        handlemap_VkDescriptorAddressInfoEXT(handlemap,
+                                             (VkDescriptorAddressInfoEXT*)(toMap->pStorageBuffer));
+    }
+}
+
+void handlemap_VkDescriptorGetInfoEXT(VulkanHandleMapping* handlemap,
+                                      VkDescriptorGetInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkDescriptorDataEXT(handlemap, (VkDescriptorDataEXT*)(&toMap->data));
+}
+
+void handlemap_VkBufferCaptureDescriptorDataInfoEXT(VulkanHandleMapping* handlemap,
+                                                    VkBufferCaptureDescriptorDataInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkImageCaptureDescriptorDataInfoEXT(VulkanHandleMapping* handlemap,
+                                                   VkImageCaptureDescriptorDataInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkImage((VkImage*)&toMap->image);
+}
+
+void handlemap_VkImageViewCaptureDescriptorDataInfoEXT(
+    VulkanHandleMapping* handlemap, VkImageViewCaptureDescriptorDataInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
+    handlemap->mapHandles_VkImageView((VkImageView*)&toMap->imageView);
+}
+
+void handlemap_VkSamplerCaptureDescriptorDataInfoEXT(VulkanHandleMapping* handlemap,
+                                                     VkSamplerCaptureDescriptorDataInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkSampler((VkSampler*)&toMap->sampler);
+}
+
+void handlemap_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkOpaqueCaptureDescriptorDataCreateInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    VulkanHandleMapping* handlemap, VkAccelerationStructureCaptureDescriptorDataInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkAccelerationStructureKHR(
+        (VkAccelerationStructureKHR*)&toMap->accelerationStructure);
+    handlemap->mapHandles_VkAccelerationStructureNV(
+        (VkAccelerationStructureNV*)&toMap->accelerationStructureNV);
 }
 
 #endif
-#ifdef VK_NV_device_diagnostics_config
-void handlemap_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toMap) {
+#ifdef VK_EXT_graphics_pipeline_library
+void handlemap_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -7207,8 +7781,17 @@ void handlemap_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
     }
 }
 
-void handlemap_VkDeviceDiagnosticsConfigCreateInfoNV(VulkanHandleMapping* handlemap,
-                                                     VkDeviceDiagnosticsConfigCreateInfoNV* toMap) {
+void handlemap_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkGraphicsPipelineLibraryCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkGraphicsPipelineLibraryCreateInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -7217,7 +7800,17 @@ void handlemap_VkDeviceDiagnosticsConfigCreateInfoNV(VulkanHandleMapping* handle
 }
 
 #endif
-#ifdef VK_QCOM_render_pass_store_ops
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+void handlemap_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
 #endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void handlemap_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -7369,8 +7962,60 @@ void handlemap_VkCopyCommandTransformInfoQCOM(VulkanHandleMapping* handlemap,
 
 #endif
 #ifdef VK_EXT_image_robustness
-void handlemap_VkPhysicalDeviceImageRobustnessFeaturesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageRobustnessFeaturesEXT* toMap) {
+#endif
+#ifdef VK_EXT_image_compression_control
+void handlemap_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageCompressionControlFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkImageCompressionControlEXT(VulkanHandleMapping* handlemap,
+                                            VkImageCompressionControlEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkSubresourceLayout2EXT(VulkanHandleMapping* handlemap,
+                                       VkSubresourceLayout2EXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkSubresourceLayout(handlemap, (VkSubresourceLayout*)(&toMap->subresourceLayout));
+}
+
+void handlemap_VkImageSubresource2EXT(VulkanHandleMapping* handlemap,
+                                      VkImageSubresource2EXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkImageSubresource(handlemap, (VkImageSubresource*)(&toMap->imageSubresource));
+}
+
+void handlemap_VkImageCompressionPropertiesEXT(VulkanHandleMapping* handlemap,
+                                               VkImageCompressionPropertiesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+void handlemap_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -7390,6 +8035,72 @@ void handlemap_VkPhysicalDevice4444FormatsFeaturesEXT(
 }
 
 #endif
+#ifdef VK_EXT_device_fault
+void handlemap_VkPhysicalDeviceFaultFeaturesEXT(VulkanHandleMapping* handlemap,
+                                                VkPhysicalDeviceFaultFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceFaultCountsEXT(VulkanHandleMapping* handlemap,
+                                      VkDeviceFaultCountsEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceFaultAddressInfoEXT(VulkanHandleMapping* handlemap,
+                                           VkDeviceFaultAddressInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkDeviceFaultVendorInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkDeviceFaultVendorInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkDeviceFaultInfoEXT(VulkanHandleMapping* handlemap, VkDeviceFaultInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pAddressInfos) {
+        handlemap_VkDeviceFaultAddressInfoEXT(handlemap,
+                                              (VkDeviceFaultAddressInfoEXT*)(toMap->pAddressInfos));
+    }
+    if (toMap->pVendorInfos) {
+        handlemap_VkDeviceFaultVendorInfoEXT(handlemap,
+                                             (VkDeviceFaultVendorInfoEXT*)(toMap->pVendorInfos));
+    }
+}
+
+void handlemap_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    VulkanHandleMapping* handlemap, VkDeviceFaultVendorBinaryHeaderVersionOneEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+void handlemap_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 void handlemap_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toMap) {
@@ -7415,8 +8126,8 @@ void handlemap_VkDirectFBSurfaceCreateInfoEXT(VulkanHandleMapping* handlemap,
 
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-void handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toMap) {
+void handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -7424,14 +8135,14 @@ void handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
     }
 }
 
-void handlemap_VkMutableDescriptorTypeListVALVE(VulkanHandleMapping* handlemap,
-                                                VkMutableDescriptorTypeListVALVE* toMap) {
+void handlemap_VkMutableDescriptorTypeListEXT(VulkanHandleMapping* handlemap,
+                                              VkMutableDescriptorTypeListEXT* toMap) {
     (void)handlemap;
     (void)toMap;
 }
 
-void handlemap_VkMutableDescriptorTypeCreateInfoVALVE(
-    VulkanHandleMapping* handlemap, VkMutableDescriptorTypeCreateInfoVALVE* toMap) {
+void handlemap_VkMutableDescriptorTypeCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                                    VkMutableDescriptorTypeCreateInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -7440,9 +8151,9 @@ void handlemap_VkMutableDescriptorTypeCreateInfoVALVE(
     if (toMap) {
         if (toMap->pMutableDescriptorTypeLists) {
             for (uint32_t i = 0; i < (uint32_t)toMap->mutableDescriptorTypeListCount; ++i) {
-                handlemap_VkMutableDescriptorTypeListVALVE(
+                handlemap_VkMutableDescriptorTypeListEXT(
                     handlemap,
-                    (VkMutableDescriptorTypeListVALVE*)(toMap->pMutableDescriptorTypeLists + i));
+                    (VkMutableDescriptorTypeListEXT*)(toMap->pMutableDescriptorTypeLists + i));
             }
         }
     }
@@ -7489,6 +8200,46 @@ void handlemap_VkPhysicalDeviceDrmPropertiesEXT(VulkanHandleMapping* handlemap,
 }
 
 #endif
+#ifdef VK_EXT_device_address_binding_report
+void handlemap_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceAddressBindingReportFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDeviceAddressBindingCallbackDataEXT(VulkanHandleMapping* handlemap,
+                                                     VkDeviceAddressBindingCallbackDataEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_depth_clip_control
+void handlemap_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthClipControlFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkPipelineViewportDepthClipControlCreateInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 void handlemap_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
     VulkanHandleMapping* handlemap,
@@ -7645,9 +8396,13 @@ void handlemap_VkImageFormatConstraintsInfoFUCHSIA(VulkanHandleMapping* handlema
         handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
     }
     handlemap_VkImageCreateInfo(handlemap, (VkImageCreateInfo*)(&toMap->imageCreateInfo));
-    if (toMap->pColorSpaces) {
-        handlemap_VkSysmemColorSpaceFUCHSIA(handlemap,
-                                            (VkSysmemColorSpaceFUCHSIA*)(toMap->pColorSpaces));
+    if (toMap) {
+        if (toMap->pColorSpaces) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->colorSpaceCount; ++i) {
+                handlemap_VkSysmemColorSpaceFUCHSIA(
+                    handlemap, (VkSysmemColorSpaceFUCHSIA*)(toMap->pColorSpaces + i));
+            }
+        }
     }
 }
 
@@ -7735,6 +8490,56 @@ void handlemap_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
 }
 
 #endif
+#ifdef VK_EXT_pipeline_properties
+void handlemap_VkPipelinePropertiesIdentifierEXT(VulkanHandleMapping* handlemap,
+                                                 VkPipelinePropertiesIdentifierEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelinePropertiesFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+void handlemap_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkSubpassResolvePerformanceQueryEXT(VulkanHandleMapping* handlemap,
+                                                   VkSubpassResolvePerformanceQueryEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMultisampledRenderToSingleSampledInfoEXT(
+    VulkanHandleMapping* handlemap, VkMultisampledRenderToSingleSampledInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void handlemap_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toMap) {
@@ -7777,6 +8582,17 @@ void handlemap_VkPipelineColorWriteCreateInfoEXT(VulkanHandleMapping* handlemap,
 }
 
 #endif
+#ifdef VK_EXT_primitives_generated_query
+void handlemap_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
 #ifdef VK_GOOGLE_gfxstream
 void handlemap_VkImportColorBufferGOOGLE(VulkanHandleMapping* handlemap,
                                          VkImportColorBufferGOOGLE* toMap) {
@@ -7805,8 +8621,10 @@ void handlemap_VkCreateBlobGOOGLE(VulkanHandleMapping* handlemap, VkCreateBlobGO
 
 #endif
 #ifdef VK_EXT_global_priority_query
-void handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toMap) {
+#endif
+#ifdef VK_EXT_image_view_min_lod
+void handlemap_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageViewMinLodFeaturesEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -7814,8 +8632,8 @@ void handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
     }
 }
 
-void handlemap_VkQueueFamilyGlobalPriorityPropertiesEXT(
-    VulkanHandleMapping* handlemap, VkQueueFamilyGlobalPriorityPropertiesEXT* toMap) {
+void handlemap_VkImageViewMinLodCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                              VkImageViewMinLodCreateInfoEXT* toMap) {
     (void)handlemap;
     (void)toMap;
     if (toMap->pNext) {
@@ -7855,8 +8673,245 @@ void handlemap_VkMultiDrawIndexedInfoEXT(VulkanHandleMapping* handlemap,
 }
 
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+void handlemap_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_tile_image
+void handlemap_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTileImageFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTileImagePropertiesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_opacity_micromap
+void handlemap_VkMicromapUsageEXT(VulkanHandleMapping* handlemap, VkMicromapUsageEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkDeviceOrHostAddressKHR(VulkanHandleMapping* handlemap,
+                                        VkDeviceOrHostAddressKHR* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkMicromapBuildInfoEXT(VulkanHandleMapping* handlemap,
+                                      VkMicromapBuildInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkMicromapEXT((VkMicromapEXT*)&toMap->dstMicromap);
+    if (toMap) {
+        if (toMap->pUsageCounts) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->usageCountsCount; ++i) {
+                handlemap_VkMicromapUsageEXT(handlemap,
+                                             (VkMicromapUsageEXT*)(toMap->pUsageCounts + i));
+            }
+        }
+    }
+    handlemap_VkDeviceOrHostAddressConstKHR(handlemap,
+                                            (VkDeviceOrHostAddressConstKHR*)(&toMap->data));
+    handlemap_VkDeviceOrHostAddressKHR(handlemap, (VkDeviceOrHostAddressKHR*)(&toMap->scratchData));
+    handlemap_VkDeviceOrHostAddressConstKHR(
+        handlemap, (VkDeviceOrHostAddressConstKHR*)(&toMap->triangleArray));
+}
+
+void handlemap_VkMicromapCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                       VkMicromapCreateInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkBuffer((VkBuffer*)&toMap->buffer);
+}
+
+void handlemap_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceOpacityMicromapFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceOpacityMicromapPropertiesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMicromapVersionInfoEXT(VulkanHandleMapping* handlemap,
+                                        VkMicromapVersionInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkCopyMicromapToMemoryInfoEXT(VulkanHandleMapping* handlemap,
+                                             VkCopyMicromapToMemoryInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkMicromapEXT((VkMicromapEXT*)&toMap->src);
+    handlemap_VkDeviceOrHostAddressKHR(handlemap, (VkDeviceOrHostAddressKHR*)(&toMap->dst));
+}
+
+void handlemap_VkCopyMemoryToMicromapInfoEXT(VulkanHandleMapping* handlemap,
+                                             VkCopyMemoryToMicromapInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkDeviceOrHostAddressConstKHR(handlemap,
+                                            (VkDeviceOrHostAddressConstKHR*)(&toMap->src));
+    handlemap->mapHandles_VkMicromapEXT((VkMicromapEXT*)&toMap->dst);
+}
+
+void handlemap_VkCopyMicromapInfoEXT(VulkanHandleMapping* handlemap, VkCopyMicromapInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkMicromapEXT((VkMicromapEXT*)&toMap->src);
+    handlemap->mapHandles_VkMicromapEXT((VkMicromapEXT*)&toMap->dst);
+}
+
+void handlemap_VkMicromapBuildSizesInfoEXT(VulkanHandleMapping* handlemap,
+                                           VkMicromapBuildSizesInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    VulkanHandleMapping* handlemap, VkAccelerationStructureTrianglesOpacityMicromapEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkDeviceOrHostAddressConstKHR(handlemap,
+                                            (VkDeviceOrHostAddressConstKHR*)(&toMap->indexBuffer));
+    if (toMap) {
+        if (toMap->pUsageCounts) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->usageCountsCount; ++i) {
+                handlemap_VkMicromapUsageEXT(handlemap,
+                                             (VkMicromapUsageEXT*)(toMap->pUsageCounts + i));
+            }
+        }
+    }
+    handlemap->mapHandles_VkMicromapEXT((VkMicromapEXT*)&toMap->micromap);
+}
+
+void handlemap_VkMicromapTriangleEXT(VulkanHandleMapping* handlemap, VkMicromapTriangleEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+#endif
+#ifdef VK_NV_displacement_micromap
+void handlemap_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDisplacementMicromapFeaturesNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDisplacementMicromapPropertiesNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    VulkanHandleMapping* handlemap, VkAccelerationStructureTrianglesDisplacementMicromapNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkDeviceOrHostAddressConstKHR(
+        handlemap, (VkDeviceOrHostAddressConstKHR*)(&toMap->displacementBiasAndScaleBuffer));
+    handlemap_VkDeviceOrHostAddressConstKHR(
+        handlemap, (VkDeviceOrHostAddressConstKHR*)(&toMap->displacementVectorBuffer));
+    handlemap_VkDeviceOrHostAddressConstKHR(
+        handlemap, (VkDeviceOrHostAddressConstKHR*)(&toMap->displacedMicromapPrimitiveFlags));
+    handlemap_VkDeviceOrHostAddressConstKHR(handlemap,
+                                            (VkDeviceOrHostAddressConstKHR*)(&toMap->indexBuffer));
+    if (toMap) {
+        if (toMap->pUsageCounts) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->usageCountsCount; ++i) {
+                handlemap_VkMicromapUsageEXT(handlemap,
+                                             (VkMicromapUsageEXT*)(toMap->pUsageCounts + i));
+            }
+        }
+    }
+    handlemap->mapHandles_VkMicromapEXT((VkMicromapEXT*)&toMap->micromap);
+}
+
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void handlemap_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_border_color_swizzle
 void handlemap_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toMap) {
@@ -7889,13 +8944,692 @@ void handlemap_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
 }
 
 #endif
-#ifdef VK_KHR_acceleration_structure
-void handlemap_VkDeviceOrHostAddressKHR(VulkanHandleMapping* handlemap,
-                                        VkDeviceOrHostAddressKHR* toMap) {
+#ifdef VK_ARM_shader_core_properties
+void handlemap_VkPhysicalDeviceShaderCorePropertiesARM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCorePropertiesARM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+void handlemap_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkImageViewSlicedCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                              VkImageViewSlicedCreateInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void handlemap_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDescriptorSetBindingReferenceVALVE(VulkanHandleMapping* handlemap,
+                                                    VkDescriptorSetBindingReferenceVALVE* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap->mapHandles_VkDescriptorSetLayout(
+        (VkDescriptorSetLayout*)&toMap->descriptorSetLayout);
+}
+
+void handlemap_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    VulkanHandleMapping* handlemap, VkDescriptorSetLayoutHostMappingInfoVALVE* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+void handlemap_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+void handlemap_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+void handlemap_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->fragmentDensityOffsetGranularity));
+}
+
+void handlemap_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    VulkanHandleMapping* handlemap, VkSubpassFragmentDensityMapOffsetEndInfoQCOM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap) {
+        if (toMap->pFragmentDensityOffsets) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->fragmentDensityOffsetCount; ++i) {
+                handlemap_VkOffset2D(handlemap, (VkOffset2D*)(toMap->pFragmentDensityOffsets + i));
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void handlemap_VkCopyMemoryIndirectCommandNV(VulkanHandleMapping* handlemap,
+                                             VkCopyMemoryIndirectCommandNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkCopyMemoryToImageIndirectCommandNV(VulkanHandleMapping* handlemap,
+                                                    VkCopyMemoryToImageIndirectCommandNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    handlemap_VkImageSubresourceLayers(handlemap,
+                                       (VkImageSubresourceLayers*)(&toMap->imageSubresource));
+    handlemap_VkOffset3D(handlemap, (VkOffset3D*)(&toMap->imageOffset));
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->imageExtent));
+}
+
+void handlemap_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_memory_decompression
+void handlemap_VkDecompressMemoryRegionNV(VulkanHandleMapping* handlemap,
+                                          VkDecompressMemoryRegionNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMemoryDecompressionFeaturesNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMemoryDecompressionPropertiesNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_linear_color_attachment
+void handlemap_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceLinearColorAttachmentFeaturesNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+void handlemap_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_image_processing
+void handlemap_VkImageViewSampleWeightCreateInfoQCOM(VulkanHandleMapping* handlemap,
+                                                     VkImageViewSampleWeightCreateInfoQCOM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->filterCenter));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->filterSize));
+}
+
+void handlemap_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageProcessingFeaturesQCOM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageProcessingPropertiesQCOM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxWeightFilterDimension));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxBlockMatchRegion));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->maxBoxFilterBlockSize));
+}
+
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void handlemap_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkColorBlendEquationEXT(VulkanHandleMapping* handlemap,
+                                       VkColorBlendEquationEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkColorBlendAdvancedEXT(VulkanHandleMapping* handlemap,
+                                       VkColorBlendAdvancedEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+void handlemap_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkRenderPassCreationControlEXT(VulkanHandleMapping* handlemap,
+                                              VkRenderPassCreationControlEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkRenderPassCreationFeedbackInfoEXT(VulkanHandleMapping* handlemap,
+                                                   VkRenderPassCreationFeedbackInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkRenderPassCreationFeedbackCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkRenderPassCreationFeedbackCreateInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pRenderPassFeedback) {
+        handlemap_VkRenderPassCreationFeedbackInfoEXT(
+            handlemap, (VkRenderPassCreationFeedbackInfoEXT*)(toMap->pRenderPassFeedback));
+    }
+}
+
+void handlemap_VkRenderPassSubpassFeedbackInfoEXT(VulkanHandleMapping* handlemap,
+                                                  VkRenderPassSubpassFeedbackInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+void handlemap_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkRenderPassSubpassFeedbackCreateInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pSubpassFeedback) {
+        handlemap_VkRenderPassSubpassFeedbackInfoEXT(
+            handlemap, (VkRenderPassSubpassFeedbackInfoEXT*)(toMap->pSubpassFeedback));
+    }
+}
+
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+void handlemap_VkDirectDriverLoadingInfoLUNARG(VulkanHandleMapping* handlemap,
+                                               VkDirectDriverLoadingInfoLUNARG* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDirectDriverLoadingListLUNARG(VulkanHandleMapping* handlemap,
+                                               VkDirectDriverLoadingListLUNARG* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap) {
+        if (toMap->pDrivers) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->driverCount; ++i) {
+                handlemap_VkDirectDriverLoadingInfoLUNARG(
+                    handlemap, (VkDirectDriverLoadingInfoLUNARG*)(toMap->pDrivers + i));
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void handlemap_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkPipelineShaderStageModuleIdentifierCreateInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkShaderModuleIdentifierEXT(VulkanHandleMapping* handlemap,
+                                           VkShaderModuleIdentifierEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+void handlemap_VkPhysicalDeviceOpticalFlowFeaturesNV(VulkanHandleMapping* handlemap,
+                                                     VkPhysicalDeviceOpticalFlowFeaturesNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceOpticalFlowPropertiesNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkOpticalFlowImageFormatInfoNV(VulkanHandleMapping* handlemap,
+                                              VkOpticalFlowImageFormatInfoNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkOpticalFlowImageFormatPropertiesNV(VulkanHandleMapping* handlemap,
+                                                    VkOpticalFlowImageFormatPropertiesNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkOpticalFlowSessionCreateInfoNV(VulkanHandleMapping* handlemap,
+                                                VkOpticalFlowSessionCreateInfoNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    VulkanHandleMapping* handlemap, VkOpticalFlowSessionCreatePrivateDataInfoNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkOpticalFlowExecuteInfoNV(VulkanHandleMapping* handlemap,
+                                          VkOpticalFlowExecuteInfoNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap) {
+        if (toMap->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->regionCount; ++i) {
+                handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pRegions + i));
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_legacy_dithering
+void handlemap_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceLegacyDitheringFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+void handlemap_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_object
+void handlemap_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderObjectFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderObjectPropertiesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkShaderCreateInfoEXT(VulkanHandleMapping* handlemap, VkShaderCreateInfoEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap->pSetLayouts) {
+        handlemap->mapHandles_VkDescriptorSetLayout((VkDescriptorSetLayout*)toMap->pSetLayouts,
+                                                    toMap->setLayoutCount);
+    }
+    if (toMap) {
+        if (toMap->pPushConstantRanges) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->pushConstantRangeCount; ++i) {
+                handlemap_VkPushConstantRange(
+                    handlemap, (VkPushConstantRange*)(toMap->pPushConstantRanges + i));
+            }
+        }
+    }
+    if (toMap->pSpecializationInfo) {
+        handlemap_VkSpecializationInfo(handlemap,
+                                       (VkSpecializationInfo*)(toMap->pSpecializationInfo));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_tile_properties
+void handlemap_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceTilePropertiesFeaturesQCOM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkTilePropertiesQCOM(VulkanHandleMapping* handlemap, VkTilePropertiesQCOM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    handlemap_VkExtent3D(handlemap, (VkExtent3D*)(&toMap->tileSize));
+    handlemap_VkExtent2D(handlemap, (VkExtent2D*)(&toMap->apronSize));
+    handlemap_VkOffset2D(handlemap, (VkOffset2D*)(&toMap->origin));
+}
+
+#endif
+#ifdef VK_SEC_amigo_profiling
+void handlemap_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceAmigoProfilingFeaturesSEC* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkAmigoProfilingSubmitInfoSEC(VulkanHandleMapping* handlemap,
+                                             VkAmigoProfilingSubmitInfoSEC* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+void handlemap_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+void handlemap_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* toMap) {
     (void)handlemap;
     (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
 }
 
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+void handlemap_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+void handlemap_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+void handlemap_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    VulkanHandleMapping* handlemap, VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+    if (toMap) {
+        if (toMap->pPerViewRenderAreas) {
+            for (uint32_t i = 0; i < (uint32_t)toMap->perViewRenderAreaCount; ++i) {
+                handlemap_VkRect2D(handlemap, (VkRect2D*)(toMap->pPerViewRenderAreas + i));
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+void handlemap_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_acceleration_structure
 void handlemap_VkAccelerationStructureBuildRangeInfoKHR(
     VulkanHandleMapping* handlemap, VkAccelerationStructureBuildRangeInfoKHR* toMap) {
     (void)handlemap;
@@ -8190,12 +9924,45 @@ void handlemap_VkPhysicalDeviceRayQueryFeaturesKHR(VulkanHandleMapping* handlema
 }
 
 #endif
+#ifdef VK_EXT_mesh_shader
+void handlemap_VkPhysicalDeviceMeshShaderFeaturesEXT(VulkanHandleMapping* handlemap,
+                                                     VkPhysicalDeviceMeshShaderFeaturesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMeshShaderPropertiesEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+    if (toMap->pNext) {
+        handlemap_extension_struct(handlemap, (void*)(toMap->pNext));
+    }
+}
+
+void handlemap_VkDrawMeshTasksIndirectCommandEXT(VulkanHandleMapping* handlemap,
+                                                 VkDrawMeshTasksIndirectCommandEXT* toMap) {
+    (void)handlemap;
+    (void)toMap;
+}
+
+#endif
 void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExtension_out) {
     if (!structExtension_out) {
         return;
     }
     uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
     switch (structType) {
+#ifdef VK_VERSION_1_0
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
+            handlemap_VkShaderModuleCreateInfo(
+                handlemap, reinterpret_cast<VkShaderModuleCreateInfo*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_VERSION_1_1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
             handlemap_VkPhysicalDeviceSubgroupProperties(
@@ -8639,6 +10406,179 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
+            handlemap_VkPhysicalDeviceVulkan13Features(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceVulkan13Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: {
+            handlemap_VkPhysicalDeviceVulkan13Properties(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceVulkan13Properties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: {
+            handlemap_VkPipelineCreationFeedbackCreateInfo(
+                handlemap,
+                reinterpret_cast<VkPipelineCreationFeedbackCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
+            handlemap_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+                handlemap, reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
+            handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
+            handlemap_VkPhysicalDevicePrivateDataFeatures(
+                handlemap,
+                reinterpret_cast<VkPhysicalDevicePrivateDataFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: {
+            handlemap_VkDevicePrivateDataCreateInfo(
+                handlemap, reinterpret_cast<VkDevicePrivateDataCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
+            handlemap_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+                handlemap, reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: {
+            handlemap_VkMemoryBarrier2(handlemap,
+                                       reinterpret_cast<VkMemoryBarrier2*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
+            handlemap_VkPhysicalDeviceSynchronization2Features(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceSynchronization2Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
+            handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+                handlemap, reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
+            handlemap_VkPhysicalDeviceImageRobustnessFeatures(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceImageRobustnessFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
+            handlemap_VkPhysicalDeviceSubgroupSizeControlFeatures(
+                handlemap, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeatures*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
+            handlemap_VkPhysicalDeviceSubgroupSizeControlProperties(
+                handlemap, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlProperties*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: {
+            handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+                handlemap, reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
+            handlemap_VkPhysicalDeviceInlineUniformBlockFeatures(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
+            handlemap_VkPhysicalDeviceInlineUniformBlockProperties(
+                handlemap, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockProperties*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: {
+            handlemap_VkWriteDescriptorSetInlineUniformBlock(
+                handlemap,
+                reinterpret_cast<VkWriteDescriptorSetInlineUniformBlock*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: {
+            handlemap_VkDescriptorPoolInlineUniformBlockCreateInfo(
+                handlemap, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
+            handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+                handlemap, reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: {
+            handlemap_VkPipelineRenderingCreateInfo(
+                handlemap, reinterpret_cast<VkPipelineRenderingCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
+            handlemap_VkPhysicalDeviceDynamicRenderingFeatures(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: {
+            handlemap_VkCommandBufferInheritanceRenderingInfo(
+                handlemap,
+                reinterpret_cast<VkCommandBufferInheritanceRenderingInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
+            handlemap_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+                handlemap, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
+            handlemap_VkPhysicalDeviceShaderIntegerDotProductProperties(
+                handlemap, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductProperties*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
+            handlemap_VkPhysicalDeviceTexelBufferAlignmentProperties(
+                handlemap, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentProperties*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
+            handlemap_VkFormatProperties3(
+                handlemap, reinterpret_cast<VkFormatProperties3*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
+            handlemap_VkPhysicalDeviceMaintenance4Features(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceMaintenance4Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
+            handlemap_VkPhysicalDeviceMaintenance4Properties(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceMaintenance4Properties*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_KHR_swapchain
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
             handlemap_VkImageSwapchainCreateInfoKHR(
@@ -8671,42 +10611,76 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
         }
 #endif
 #ifdef VK_KHR_video_queue
-        case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
-            handlemap_VkVideoQueueFamilyProperties2KHR(
-                handlemap,
-                reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: {
+            handlemap_VkQueueFamilyQueryResultStatusPropertiesKHR(
+                handlemap, reinterpret_cast<VkQueueFamilyQueryResultStatusPropertiesKHR*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: {
+            handlemap_VkQueueFamilyVideoPropertiesKHR(
+                handlemap, reinterpret_cast<VkQueueFamilyVideoPropertiesKHR*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
-            handlemap_VkVideoProfileKHR(handlemap,
-                                        reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: {
+            handlemap_VkVideoProfileInfoKHR(
+                handlemap, reinterpret_cast<VkVideoProfileInfoKHR*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
-            handlemap_VkVideoProfilesKHR(
-                handlemap, reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: {
+            handlemap_VkVideoProfileListInfoKHR(
+                handlemap, reinterpret_cast<VkVideoProfileListInfoKHR*>(structExtension_out));
             break;
         }
 #endif
-#ifdef VK_KHR_dynamic_rendering
-        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
-            handlemap_VkPipelineRenderingCreateInfoKHR(
+#ifdef VK_KHR_video_decode_queue
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: {
+            handlemap_VkVideoDecodeCapabilitiesKHR(
+                handlemap, reinterpret_cast<VkVideoDecodeCapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: {
+            handlemap_VkVideoDecodeUsageInfoKHR(
+                handlemap, reinterpret_cast<VkVideoDecodeUsageInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_video_decode_h264
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: {
+            handlemap_VkVideoDecodeH264ProfileInfoKHR(
+                handlemap, reinterpret_cast<VkVideoDecodeH264ProfileInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: {
+            handlemap_VkVideoDecodeH264CapabilitiesKHR(
                 handlemap,
-                reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
+                reinterpret_cast<VkVideoDecodeH264CapabilitiesKHR*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
-            handlemap_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
-                handlemap, reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            handlemap_VkVideoDecodeH264SessionParametersAddInfoKHR(
+                handlemap, reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoKHR*>(
                                structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
-            handlemap_VkCommandBufferInheritanceRenderingInfoKHR(
-                handlemap,
-                reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            handlemap_VkVideoDecodeH264SessionParametersCreateInfoKHR(
+                handlemap, reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoKHR*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: {
+            handlemap_VkVideoDecodeH264PictureInfoKHR(
+                handlemap, reinterpret_cast<VkVideoDecodeH264PictureInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: {
+            handlemap_VkVideoDecodeH264DpbSlotInfoKHR(
+                handlemap, reinterpret_cast<VkVideoDecodeH264DpbSlotInfoKHR*>(structExtension_out));
             break;
         }
+#endif
+#ifdef VK_KHR_dynamic_rendering
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
             handlemap_VkRenderingFragmentShadingRateAttachmentInfoKHR(
                 handlemap, reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
@@ -8829,18 +10803,22 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
         }
 #endif
 #ifdef VK_KHR_portability_subset
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
             handlemap_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
                 handlemap, reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                                structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
             handlemap_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
                 handlemap, reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
                                structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_shader_clock
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
@@ -8850,13 +10828,60 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_KHR_shader_terminate_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
-            handlemap_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
-                handlemap, reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+#ifdef VK_KHR_video_decode_h265
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: {
+            handlemap_VkVideoDecodeH265ProfileInfoKHR(
+                handlemap, reinterpret_cast<VkVideoDecodeH265ProfileInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: {
+            handlemap_VkVideoDecodeH265CapabilitiesKHR(
+                handlemap,
+                reinterpret_cast<VkVideoDecodeH265CapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            handlemap_VkVideoDecodeH265SessionParametersAddInfoKHR(
+                handlemap, reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoKHR*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            handlemap_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+                handlemap, reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoKHR*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: {
+            handlemap_VkVideoDecodeH265PictureInfoKHR(
+                handlemap, reinterpret_cast<VkVideoDecodeH265PictureInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: {
+            handlemap_VkVideoDecodeH265DpbSlotInfoKHR(
+                handlemap, reinterpret_cast<VkVideoDecodeH265DpbSlotInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: {
+            handlemap_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+                handlemap,
+                reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: {
+            handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+                handlemap, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(
                                structExtension_out));
             break;
         }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: {
+            handlemap_VkQueueFamilyGlobalPriorityPropertiesKHR(
+                handlemap,
+                reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesKHR*>(structExtension_out));
+            break;
+        }
 #endif
 #ifdef VK_KHR_fragment_shading_rate
         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
@@ -8909,17 +10934,10 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
-            handlemap_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-                handlemap, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
-                               structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
-            handlemap_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-                handlemap, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
-                               structExtension_out));
+#ifdef VK_KHR_pipeline_library
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+            handlemap_VkPipelineLibraryCreateInfoKHR(
+                handlemap, reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(structExtension_out));
             break;
         }
 #endif
@@ -8937,28 +10955,64 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
         }
 #endif
 #ifdef VK_KHR_video_encode_queue
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: {
+            handlemap_VkVideoEncodeCapabilitiesKHR(
+                handlemap, reinterpret_cast<VkVideoEncodeCapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: {
+            handlemap_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+                handlemap, reinterpret_cast<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(
+                               structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: {
+            handlemap_VkVideoEncodeUsageInfoKHR(
+                handlemap, reinterpret_cast<VkVideoEncodeUsageInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: {
+            handlemap_VkVideoEncodeRateControlLayerInfoKHR(
+                handlemap,
+                reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
             handlemap_VkVideoEncodeRateControlInfoKHR(
                 handlemap, reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_synchronization2
-        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
-            handlemap_VkMemoryBarrier2KHR(
-                handlemap, reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
+            handlemap_VkQueueFamilyCheckpointProperties2NV(
+                handlemap,
+                reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
-            handlemap_VkPhysicalDeviceSynchronization2FeaturesKHR(
-                handlemap, reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+#endif
+#ifdef VK_KHR_fragment_shader_barycentric
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
+            handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+                handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(
                                structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
-            handlemap_VkQueueFamilyCheckpointProperties2NV(
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: {
+            handlemap_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
                 handlemap,
-                reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(
+                    structExtension_out));
             break;
         }
 #endif
@@ -8971,15 +11025,6 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_KHR_zero_initialize_workgroup_memory
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
-            handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-                handlemap,
-                reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
             handlemap_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
@@ -8989,24 +11034,19 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_KHR_format_feature_flags2
-        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
-            handlemap_VkFormatProperties3KHR(
-                handlemap, reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
+#ifdef VK_KHR_ray_tracing_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
+            handlemap_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+                handlemap, reinterpret_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
+                               structExtension_out));
             break;
         }
 #endif
-#ifdef VK_KHR_maintenance4
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
-            handlemap_VkPhysicalDeviceMaintenance4FeaturesKHR(
-                handlemap,
-                reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
-            handlemap_VkPhysicalDeviceMaintenance4PropertiesKHR(
-                handlemap,
-                reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
+#ifdef VK_KHR_ray_tracing_position_fetch
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
+            handlemap_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+                handlemap, reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(
+                               structExtension_out));
             break;
         }
 #endif
@@ -9074,136 +11114,132 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
         }
 #endif
 #ifdef VK_EXT_video_encode_h264
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
             handlemap_VkVideoEncodeH264CapabilitiesEXT(
                 handlemap,
                 reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
-            handlemap_VkVideoEncodeH264SessionCreateInfoEXT(
-                handlemap,
-                reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
             handlemap_VkVideoEncodeH264SessionParametersAddInfoEXT(
                 handlemap, reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(
                                structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             handlemap_VkVideoEncodeH264SessionParametersCreateInfoEXT(
                 handlemap, reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
                                structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
             handlemap_VkVideoEncodeH264VclFrameInfoEXT(
                 handlemap,
                 reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
-            handlemap_VkVideoEncodeH264EmitPictureParametersEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: {
+            handlemap_VkVideoEncodeH264DpbSlotInfoEXT(
+                handlemap, reinterpret_cast<VkVideoEncodeH264DpbSlotInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: {
+            handlemap_VkVideoEncodeH264ProfileInfoEXT(
+                handlemap, reinterpret_cast<VkVideoEncodeH264ProfileInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: {
+            handlemap_VkVideoEncodeH264RateControlInfoEXT(
                 handlemap,
-                reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH264RateControlInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
-            handlemap_VkVideoEncodeH264ProfileEXT(
-                handlemap, reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: {
+            handlemap_VkVideoEncodeH264RateControlLayerInfoEXT(
+                handlemap,
+                reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoEXT*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_EXT_video_encode_h265
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
             handlemap_VkVideoEncodeH265CapabilitiesEXT(
                 handlemap,
                 reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
-            handlemap_VkVideoEncodeH265SessionCreateInfoEXT(
-                handlemap,
-                reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
             handlemap_VkVideoEncodeH265SessionParametersAddInfoEXT(
                 handlemap, reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(
                                structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             handlemap_VkVideoEncodeH265SessionParametersCreateInfoEXT(
                 handlemap, reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
                                structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
             handlemap_VkVideoEncodeH265VclFrameInfoEXT(
                 handlemap,
                 reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
-            handlemap_VkVideoEncodeH265EmitPictureParametersEXT(
-                handlemap,
-                reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
-            handlemap_VkVideoEncodeH265ProfileEXT(
-                handlemap, reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: {
+            handlemap_VkVideoEncodeH265DpbSlotInfoEXT(
+                handlemap, reinterpret_cast<VkVideoEncodeH265DpbSlotInfoEXT*>(structExtension_out));
             break;
         }
-#endif
-#ifdef VK_EXT_video_decode_h264
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
-            handlemap_VkVideoDecodeH264ProfileEXT(
-                handlemap, reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: {
+            handlemap_VkVideoEncodeH265ProfileInfoEXT(
+                handlemap, reinterpret_cast<VkVideoEncodeH265ProfileInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
-            handlemap_VkVideoDecodeH264CapabilitiesEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: {
+            handlemap_VkVideoEncodeH265RateControlInfoEXT(
                 handlemap,
-                reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265RateControlInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
-            handlemap_VkVideoDecodeH264SessionCreateInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: {
+            handlemap_VkVideoEncodeH265RateControlLayerInfoEXT(
                 handlemap,
-                reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            handlemap_VkVideoDecodeH264SessionParametersAddInfoEXT(
-                handlemap, reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(
-                               structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            handlemap_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-                handlemap, reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
-                               structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
-            handlemap_VkVideoDecodeH264PictureInfoEXT(
-                handlemap, reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
-            handlemap_VkVideoDecodeH264MvcEXT(
-                handlemap, reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
-            handlemap_VkVideoDecodeH264DpbSlotInfoEXT(
-                handlemap, reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoEXT*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
@@ -9261,14 +11297,6 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_EXT_texture_compression_astc_hdr
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
-            handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-                handlemap, reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
-                               structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_astc_decode_mode
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
             handlemap_VkImageViewASTCDecodeModeEXT(
@@ -9282,6 +11310,26 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_robustness
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: {
+            handlemap_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: {
+            handlemap_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: {
+            handlemap_VkPipelineRobustnessCreateInfoEXT(
+                handlemap,
+                reinterpret_cast<VkPipelineRobustnessCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_conditional_rendering
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
             handlemap_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
@@ -9379,6 +11427,11 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
         }
 #endif
 #ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+            handlemap_VkDebugUtilsObjectNameInfoEXT(
+                handlemap, reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(structExtension_out));
+            break;
+        }
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
             handlemap_VkDebugUtilsMessengerCreateInfoEXT(
                 handlemap,
@@ -9417,32 +11470,6 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_EXT_inline_uniform_block
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
-            handlemap_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-                handlemap, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
-                               structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
-            handlemap_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-                handlemap, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
-                               structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
-            handlemap_VkWriteDescriptorSetInlineUniformBlockEXT(
-                handlemap,
-                reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
-            handlemap_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-                handlemap, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
-                               structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_sample_locations
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
             handlemap_VkSampleLocationsInfoEXT(
@@ -9626,14 +11653,6 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
-            handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-                handlemap,
-                reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_external_memory_host
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
             handlemap_VkImportMemoryHostPointerInfoEXT(
@@ -9664,47 +11683,6 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_EXT_video_decode_h265
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
-            handlemap_VkVideoDecodeH265ProfileEXT(
-                handlemap, reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
-            handlemap_VkVideoDecodeH265CapabilitiesEXT(
-                handlemap,
-                reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
-            handlemap_VkVideoDecodeH265SessionCreateInfoEXT(
-                handlemap,
-                reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            handlemap_VkVideoDecodeH265SessionParametersAddInfoEXT(
-                handlemap, reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(
-                               structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            handlemap_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-                handlemap, reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
-                               structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
-            handlemap_VkVideoDecodeH265PictureInfoEXT(
-                handlemap, reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
-            handlemap_VkVideoDecodeH265DpbSlotInfoEXT(
-                handlemap, reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
             handlemap_VkDeviceMemoryOverallocationCreateInfoAMD(
@@ -9740,14 +11718,6 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_EXT_pipeline_creation_feedback
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
-            handlemap_VkPipelineCreationFeedbackCreateInfoEXT(
-                handlemap,
-                reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_NV_compute_shader_derivatives
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
             handlemap_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
@@ -9770,14 +11740,6 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_NV_fragment_shader_barycentric
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
-            handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-                handlemap, reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
-                               structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_NV_shader_image_footprint
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
             handlemap_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -9866,27 +11828,6 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_EXT_subgroup_size_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
-            handlemap_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-                handlemap, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
-                               structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
-            handlemap_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-                handlemap, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
-                               structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
-            handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-                handlemap,
-                reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_AMD_shader_core_properties2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
             handlemap_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -10099,12 +12040,52 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
-            handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: {
+            handlemap_VkSurfacePresentModeEXT(
+                handlemap, reinterpret_cast<VkSurfacePresentModeEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
+            handlemap_VkSurfacePresentScalingCapabilitiesEXT(
                 handlemap,
-                reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
-                    structExtension_out));
+                reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
+            handlemap_VkSurfacePresentModeCompatibilityEXT(
+                handlemap,
+                reinterpret_cast<VkSurfacePresentModeCompatibilityEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: {
+            handlemap_VkSwapchainPresentFenceInfoEXT(
+                handlemap, reinterpret_cast<VkSwapchainPresentFenceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: {
+            handlemap_VkSwapchainPresentModesCreateInfoEXT(
+                handlemap,
+                reinterpret_cast<VkSwapchainPresentModesCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: {
+            handlemap_VkSwapchainPresentModeInfoEXT(
+                handlemap, reinterpret_cast<VkSwapchainPresentModeInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: {
+            handlemap_VkSwapchainPresentScalingCreateInfoEXT(
+                handlemap,
+                reinterpret_cast<VkSwapchainPresentScalingCreateInfoEXT*>(structExtension_out));
             break;
         }
 #endif
@@ -10149,12 +12130,6 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
                                structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
-            handlemap_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-                handlemap, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
-                               structExtension_out));
-            break;
-        }
 #endif
 #ifdef VK_QCOM_render_pass_transform
         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
@@ -10218,26 +12193,23 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_EXT_private_data
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
-            handlemap_VkPhysicalDevicePrivateDataFeaturesEXT(
+#ifdef VK_NV_present_barrier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
+            handlemap_VkPhysicalDevicePresentBarrierFeaturesNV(
                 handlemap,
-                reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDevicePresentBarrierFeaturesNV*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
-            handlemap_VkDevicePrivateDataCreateInfoEXT(
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: {
+            handlemap_VkSurfaceCapabilitiesPresentBarrierNV(
                 handlemap,
-                reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
+                reinterpret_cast<VkSurfaceCapabilitiesPresentBarrierNV*>(structExtension_out));
             break;
         }
-#endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
-            handlemap_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: {
+            handlemap_VkSwapchainPresentBarrierCreateInfoNV(
                 handlemap,
-                reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
-                    structExtension_out));
+                reinterpret_cast<VkSwapchainPresentBarrierCreateInfoNV*>(structExtension_out));
             break;
         }
 #endif
@@ -10255,6 +12227,135 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
+#ifdef VK_NV_low_latency
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: {
+            handlemap_VkQueryLowLatencySupportNV(
+                handlemap, reinterpret_cast<VkQueryLowLatencySupportNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_metal_objects
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: {
+            handlemap_VkExportMetalObjectCreateInfoEXT(
+                handlemap,
+                reinterpret_cast<VkExportMetalObjectCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: {
+            handlemap_VkExportMetalDeviceInfoEXT(
+                handlemap, reinterpret_cast<VkExportMetalDeviceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: {
+            handlemap_VkExportMetalCommandQueueInfoEXT(
+                handlemap,
+                reinterpret_cast<VkExportMetalCommandQueueInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: {
+            handlemap_VkExportMetalBufferInfoEXT(
+                handlemap, reinterpret_cast<VkExportMetalBufferInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: {
+            handlemap_VkImportMetalBufferInfoEXT(
+                handlemap, reinterpret_cast<VkImportMetalBufferInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: {
+            handlemap_VkExportMetalTextureInfoEXT(
+                handlemap, reinterpret_cast<VkExportMetalTextureInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: {
+            handlemap_VkImportMetalTextureInfoEXT(
+                handlemap, reinterpret_cast<VkImportMetalTextureInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: {
+            handlemap_VkExportMetalIOSurfaceInfoEXT(
+                handlemap, reinterpret_cast<VkExportMetalIOSurfaceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: {
+            handlemap_VkImportMetalIOSurfaceInfoEXT(
+                handlemap, reinterpret_cast<VkImportMetalIOSurfaceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            handlemap_VkExportMetalSharedEventInfoEXT(
+                handlemap, reinterpret_cast<VkExportMetalSharedEventInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            handlemap_VkImportMetalSharedEventInfoEXT(
+                handlemap, reinterpret_cast<VkImportMetalSharedEventInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: {
+            handlemap_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: {
+            handlemap_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: {
+            handlemap_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+                handlemap,
+                reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: {
+            handlemap_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+                handlemap,
+                reinterpret_cast<VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: {
+            handlemap_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: {
+            handlemap_VkGraphicsPipelineLibraryCreateInfoEXT(
+                handlemap,
+                reinterpret_cast<VkGraphicsPipelineLibraryCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
+            handlemap_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
             handlemap_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -10324,11 +12425,30 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_EXT_image_robustness
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
-            handlemap_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+#ifdef VK_EXT_image_compression_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
+            handlemap_VkImageCompressionControlEXT(
+                handlemap, reinterpret_cast<VkImageCompressionControlEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
+            handlemap_VkImageCompressionPropertiesEXT(
+                handlemap, reinterpret_cast<VkImageCompressionPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
                 handlemap,
-                reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(
+                    structExtension_out));
             break;
         }
 #endif
@@ -10340,6 +12460,23 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
+#ifdef VK_EXT_device_fault
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceFaultFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceFaultFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_rgba10x6_formats
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
             handlemap_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
@@ -10349,16 +12486,16 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
         }
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
-            handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
-                handlemap, reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(
                                structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
-            handlemap_VkMutableDescriptorTypeCreateInfoVALVE(
+        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: {
+            handlemap_VkMutableDescriptorTypeCreateInfoEXT(
                 handlemap,
-                reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
+                reinterpret_cast<VkMutableDescriptorTypeCreateInfoEXT*>(structExtension_out));
             break;
         }
 #endif
@@ -10378,6 +12515,34 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
+#ifdef VK_EXT_device_address_binding_report
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: {
+            handlemap_VkDeviceAddressBindingCallbackDataEXT(
+                handlemap,
+                reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clip_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: {
+            handlemap_VkPipelineViewportDepthClipControlCreateInfoEXT(
+                handlemap, reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT*>(
+                               structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
             handlemap_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
@@ -10451,6 +12616,35 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
+            handlemap_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: {
+            handlemap_VkSubpassResolvePerformanceQueryEXT(
+                handlemap,
+                reinterpret_cast<VkSubpassResolvePerformanceQueryEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: {
+            handlemap_VkMultisampledRenderToSingleSampledInfoEXT(
+                handlemap,
+                reinterpret_cast<VkMultisampledRenderToSingleSampledInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
             handlemap_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
@@ -10473,6 +12667,14 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
+#ifdef VK_EXT_primitives_generated_query
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
+            handlemap_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_GOOGLE_gfxstream
         case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
             handlemap_VkImportColorBufferGOOGLE(
@@ -10490,17 +12692,16 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority_query
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
-            handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
-                handlemap, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
-                               structExtension_out));
+#ifdef VK_EXT_image_view_min_lod
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
-            handlemap_VkQueueFamilyGlobalPriorityPropertiesEXT(
-                handlemap,
-                reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: {
+            handlemap_VkImageViewMinLodCreateInfoEXT(
+                handlemap, reinterpret_cast<VkImageViewMinLodCreateInfoEXT*>(structExtension_out));
             break;
         }
 #endif
@@ -10518,6 +12719,89 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_tile_image
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: {
+            handlemap_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceShaderTileImagePropertiesEXT*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: {
+            handlemap_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: {
+            handlemap_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+                handlemap, reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapEXT*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_displacement_micromap
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
+            handlemap_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+                handlemap, reinterpret_cast<VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(
+                               structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: {
+            handlemap_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+                handlemap, reinterpret_cast<VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(
+                               structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: {
+            handlemap_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+                handlemap,
+                reinterpret_cast<VkAccelerationStructureTrianglesDisplacementMicromapNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
+            handlemap_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+                handlemap, reinterpret_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: {
+            handlemap_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+                handlemap, reinterpret_cast<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(
+                               structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_border_color_swizzle
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
             handlemap_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
@@ -10540,6 +12824,349 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
+#ifdef VK_ARM_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: {
+            handlemap_VkPhysicalDeviceShaderCorePropertiesARM(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesARM*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: {
+            handlemap_VkImageViewSlicedCreateInfoEXT(
+                handlemap, reinterpret_cast<VkImageViewSlicedCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
+            handlemap_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+                handlemap, reinterpret_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: {
+            handlemap_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+                handlemap, reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: {
+            handlemap_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: {
+            handlemap_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+                handlemap, reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_copy_memory_indirect
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
+            handlemap_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+                handlemap, reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: {
+            handlemap_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+                handlemap, reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_memory_decompression
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: {
+            handlemap_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+                handlemap, reinterpret_cast<VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: {
+            handlemap_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+                handlemap, reinterpret_cast<VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_linear_color_attachment
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
+            handlemap_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+                handlemap, reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_image_processing
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: {
+            handlemap_VkImageViewSampleWeightCreateInfoQCOM(
+                handlemap,
+                reinterpret_cast<VkImageViewSampleWeightCreateInfoQCOM*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
+            handlemap_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+                handlemap, reinterpret_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: {
+            handlemap_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+                handlemap, reinterpret_cast<VkPhysicalDeviceImageProcessingPropertiesQCOM*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: {
+            handlemap_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: {
+            handlemap_VkRenderPassCreationControlEXT(
+                handlemap, reinterpret_cast<VkRenderPassCreationControlEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+            handlemap_VkRenderPassCreationFeedbackCreateInfoEXT(
+                handlemap,
+                reinterpret_cast<VkRenderPassCreationFeedbackCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: {
+            handlemap_VkRenderPassSubpassFeedbackCreateInfoEXT(
+                handlemap,
+                reinterpret_cast<VkRenderPassSubpassFeedbackCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: {
+            handlemap_VkDirectDriverLoadingListLUNARG(
+                handlemap, reinterpret_cast<VkDirectDriverLoadingListLUNARG*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_module_identifier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: {
+            handlemap_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: {
+            handlemap_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+                handlemap, reinterpret_cast<VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_optical_flow
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
+            handlemap_VkPhysicalDeviceOpticalFlowFeaturesNV(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceOpticalFlowFeaturesNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: {
+            handlemap_VkPhysicalDeviceOpticalFlowPropertiesNV(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceOpticalFlowPropertiesNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: {
+            handlemap_VkOpticalFlowImageFormatInfoNV(
+                handlemap, reinterpret_cast<VkOpticalFlowImageFormatInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: {
+            handlemap_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+                handlemap, reinterpret_cast<VkOpticalFlowSessionCreatePrivateDataInfoNV*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_legacy_dithering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: {
+            handlemap_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+                handlemap, reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_object
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceShaderObjectFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceShaderObjectFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: {
+            handlemap_VkPhysicalDeviceShaderObjectPropertiesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceShaderObjectPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_tile_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
+            handlemap_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_SEC_amigo_profiling
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
+            handlemap_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: {
+            handlemap_VkAmigoProfilingSubmitInfoSEC(
+                handlemap, reinterpret_cast<VkAmigoProfilingSubmitInfoSEC*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
+            handlemap_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+                handlemap, reinterpret_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: {
+            handlemap_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
+            handlemap_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+                handlemap, reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ARM_shader_core_builtins
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
+            handlemap_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+                handlemap, reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(
+                               structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: {
+            handlemap_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+                handlemap, reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
+            handlemap_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
+            handlemap_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: {
+            handlemap_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+                handlemap, reinterpret_cast<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(
+                               structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
             handlemap_VkWriteDescriptorSetAccelerationStructureKHR(
@@ -10582,6 +13209,20 @@ void handlemap_extension_struct(VulkanHandleMapping* handlemap, void* structExte
             break;
         }
 #endif
+#ifdef VK_EXT_mesh_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
+            handlemap_VkPhysicalDeviceMeshShaderFeaturesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: {
+            handlemap_VkPhysicalDeviceMeshShaderPropertiesEXT(
+                handlemap,
+                reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
         default: {
             return;
         }
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_handlemap.h b/stream-servers/vulkan/cereal/common/goldfish_vk_handlemap.h
index 6be323a9..965e5ba7 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_handlemap.h
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_handlemap.h
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_handlemap
 //
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (header) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -668,6 +668,151 @@ void handlemap_VkDeviceMemoryOpaqueCaptureAddressInfo(
     VulkanHandleMapping* handlemap, VkDeviceMemoryOpaqueCaptureAddressInfo* toMap);
 
 #endif
+#ifdef VK_VERSION_1_3
+void handlemap_VkPhysicalDeviceVulkan13Features(VulkanHandleMapping* handlemap,
+                                                VkPhysicalDeviceVulkan13Features* toMap);
+
+void handlemap_VkPhysicalDeviceVulkan13Properties(VulkanHandleMapping* handlemap,
+                                                  VkPhysicalDeviceVulkan13Properties* toMap);
+
+void handlemap_VkPipelineCreationFeedback(VulkanHandleMapping* handlemap,
+                                          VkPipelineCreationFeedback* toMap);
+
+void handlemap_VkPipelineCreationFeedbackCreateInfo(VulkanHandleMapping* handlemap,
+                                                    VkPipelineCreationFeedbackCreateInfo* toMap);
+
+void handlemap_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTerminateInvocationFeatures* toMap);
+
+void handlemap_VkPhysicalDeviceToolProperties(VulkanHandleMapping* handlemap,
+                                              VkPhysicalDeviceToolProperties* toMap);
+
+void handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* toMap);
+
+void handlemap_VkPhysicalDevicePrivateDataFeatures(VulkanHandleMapping* handlemap,
+                                                   VkPhysicalDevicePrivateDataFeatures* toMap);
+
+void handlemap_VkDevicePrivateDataCreateInfo(VulkanHandleMapping* handlemap,
+                                             VkDevicePrivateDataCreateInfo* toMap);
+
+void handlemap_VkPrivateDataSlotCreateInfo(VulkanHandleMapping* handlemap,
+                                           VkPrivateDataSlotCreateInfo* toMap);
+
+void handlemap_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineCreationCacheControlFeatures* toMap);
+
+void handlemap_VkMemoryBarrier2(VulkanHandleMapping* handlemap, VkMemoryBarrier2* toMap);
+
+void handlemap_VkBufferMemoryBarrier2(VulkanHandleMapping* handlemap,
+                                      VkBufferMemoryBarrier2* toMap);
+
+void handlemap_VkImageMemoryBarrier2(VulkanHandleMapping* handlemap, VkImageMemoryBarrier2* toMap);
+
+void handlemap_VkDependencyInfo(VulkanHandleMapping* handlemap, VkDependencyInfo* toMap);
+
+void handlemap_VkSemaphoreSubmitInfo(VulkanHandleMapping* handlemap, VkSemaphoreSubmitInfo* toMap);
+
+void handlemap_VkCommandBufferSubmitInfo(VulkanHandleMapping* handlemap,
+                                         VkCommandBufferSubmitInfo* toMap);
+
+void handlemap_VkSubmitInfo2(VulkanHandleMapping* handlemap, VkSubmitInfo2* toMap);
+
+void handlemap_VkPhysicalDeviceSynchronization2Features(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceSynchronization2Features* toMap);
+
+void handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* toMap);
+
+void handlemap_VkPhysicalDeviceImageRobustnessFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageRobustnessFeatures* toMap);
+
+void handlemap_VkBufferCopy2(VulkanHandleMapping* handlemap, VkBufferCopy2* toMap);
+
+void handlemap_VkCopyBufferInfo2(VulkanHandleMapping* handlemap, VkCopyBufferInfo2* toMap);
+
+void handlemap_VkImageCopy2(VulkanHandleMapping* handlemap, VkImageCopy2* toMap);
+
+void handlemap_VkCopyImageInfo2(VulkanHandleMapping* handlemap, VkCopyImageInfo2* toMap);
+
+void handlemap_VkBufferImageCopy2(VulkanHandleMapping* handlemap, VkBufferImageCopy2* toMap);
+
+void handlemap_VkCopyBufferToImageInfo2(VulkanHandleMapping* handlemap,
+                                        VkCopyBufferToImageInfo2* toMap);
+
+void handlemap_VkCopyImageToBufferInfo2(VulkanHandleMapping* handlemap,
+                                        VkCopyImageToBufferInfo2* toMap);
+
+void handlemap_VkImageBlit2(VulkanHandleMapping* handlemap, VkImageBlit2* toMap);
+
+void handlemap_VkBlitImageInfo2(VulkanHandleMapping* handlemap, VkBlitImageInfo2* toMap);
+
+void handlemap_VkImageResolve2(VulkanHandleMapping* handlemap, VkImageResolve2* toMap);
+
+void handlemap_VkResolveImageInfo2(VulkanHandleMapping* handlemap, VkResolveImageInfo2* toMap);
+
+void handlemap_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlFeatures* toMap);
+
+void handlemap_VkPhysicalDeviceSubgroupSizeControlProperties(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlProperties* toMap);
+
+void handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    VulkanHandleMapping* handlemap, VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* toMap);
+
+void handlemap_VkPhysicalDeviceInlineUniformBlockFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockFeatures* toMap);
+
+void handlemap_VkPhysicalDeviceInlineUniformBlockProperties(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockProperties* toMap);
+
+void handlemap_VkWriteDescriptorSetInlineUniformBlock(
+    VulkanHandleMapping* handlemap, VkWriteDescriptorSetInlineUniformBlock* toMap);
+
+void handlemap_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    VulkanHandleMapping* handlemap, VkDescriptorPoolInlineUniformBlockCreateInfo* toMap);
+
+void handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceTextureCompressionASTCHDRFeatures* toMap);
+
+void handlemap_VkRenderingAttachmentInfo(VulkanHandleMapping* handlemap,
+                                         VkRenderingAttachmentInfo* toMap);
+
+void handlemap_VkRenderingInfo(VulkanHandleMapping* handlemap, VkRenderingInfo* toMap);
+
+void handlemap_VkPipelineRenderingCreateInfo(VulkanHandleMapping* handlemap,
+                                             VkPipelineRenderingCreateInfo* toMap);
+
+void handlemap_VkPhysicalDeviceDynamicRenderingFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDynamicRenderingFeatures* toMap);
+
+void handlemap_VkCommandBufferInheritanceRenderingInfo(
+    VulkanHandleMapping* handlemap, VkCommandBufferInheritanceRenderingInfo* toMap);
+
+void handlemap_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductFeatures* toMap);
+
+void handlemap_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductProperties* toMap);
+
+void handlemap_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceTexelBufferAlignmentProperties* toMap);
+
+void handlemap_VkFormatProperties3(VulkanHandleMapping* handlemap, VkFormatProperties3* toMap);
+
+void handlemap_VkPhysicalDeviceMaintenance4Features(VulkanHandleMapping* handlemap,
+                                                    VkPhysicalDeviceMaintenance4Features* toMap);
+
+void handlemap_VkPhysicalDeviceMaintenance4Properties(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance4Properties* toMap);
+
+void handlemap_VkDeviceBufferMemoryRequirements(VulkanHandleMapping* handlemap,
+                                                VkDeviceBufferMemoryRequirements* toMap);
+
+void handlemap_VkDeviceImageMemoryRequirements(VulkanHandleMapping* handlemap,
+                                               VkDeviceImageMemoryRequirements* toMap);
+
+#endif
 #ifdef VK_KHR_surface
 void handlemap_VkSurfaceCapabilitiesKHR(VulkanHandleMapping* handlemap,
                                         VkSurfaceCapabilitiesKHR* toMap);
@@ -756,12 +901,16 @@ void handlemap_VkWin32SurfaceCreateInfoKHR(VulkanHandleMapping* handlemap,
 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
 #endif
 #ifdef VK_KHR_video_queue
-void handlemap_VkVideoQueueFamilyProperties2KHR(VulkanHandleMapping* handlemap,
-                                                VkVideoQueueFamilyProperties2KHR* toMap);
+void handlemap_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    VulkanHandleMapping* handlemap, VkQueueFamilyQueryResultStatusPropertiesKHR* toMap);
 
-void handlemap_VkVideoProfileKHR(VulkanHandleMapping* handlemap, VkVideoProfileKHR* toMap);
+void handlemap_VkQueueFamilyVideoPropertiesKHR(VulkanHandleMapping* handlemap,
+                                               VkQueueFamilyVideoPropertiesKHR* toMap);
 
-void handlemap_VkVideoProfilesKHR(VulkanHandleMapping* handlemap, VkVideoProfilesKHR* toMap);
+void handlemap_VkVideoProfileInfoKHR(VulkanHandleMapping* handlemap, VkVideoProfileInfoKHR* toMap);
+
+void handlemap_VkVideoProfileListInfoKHR(VulkanHandleMapping* handlemap,
+                                         VkVideoProfileListInfoKHR* toMap);
 
 void handlemap_VkVideoCapabilitiesKHR(VulkanHandleMapping* handlemap,
                                       VkVideoCapabilitiesKHR* toMap);
@@ -772,16 +921,17 @@ void handlemap_VkPhysicalDeviceVideoFormatInfoKHR(VulkanHandleMapping* handlemap
 void handlemap_VkVideoFormatPropertiesKHR(VulkanHandleMapping* handlemap,
                                           VkVideoFormatPropertiesKHR* toMap);
 
-void handlemap_VkVideoPictureResourceKHR(VulkanHandleMapping* handlemap,
-                                         VkVideoPictureResourceKHR* toMap);
+void handlemap_VkVideoPictureResourceInfoKHR(VulkanHandleMapping* handlemap,
+                                             VkVideoPictureResourceInfoKHR* toMap);
 
-void handlemap_VkVideoReferenceSlotKHR(VulkanHandleMapping* handlemap,
-                                       VkVideoReferenceSlotKHR* toMap);
+void handlemap_VkVideoReferenceSlotInfoKHR(VulkanHandleMapping* handlemap,
+                                           VkVideoReferenceSlotInfoKHR* toMap);
 
-void handlemap_VkVideoGetMemoryPropertiesKHR(VulkanHandleMapping* handlemap,
-                                             VkVideoGetMemoryPropertiesKHR* toMap);
+void handlemap_VkVideoSessionMemoryRequirementsKHR(VulkanHandleMapping* handlemap,
+                                                   VkVideoSessionMemoryRequirementsKHR* toMap);
 
-void handlemap_VkVideoBindMemoryKHR(VulkanHandleMapping* handlemap, VkVideoBindMemoryKHR* toMap);
+void handlemap_VkBindVideoSessionMemoryInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkBindVideoSessionMemoryInfoKHR* toMap);
 
 void handlemap_VkVideoSessionCreateInfoKHR(VulkanHandleMapping* handlemap,
                                            VkVideoSessionCreateInfoKHR* toMap);
@@ -803,23 +953,48 @@ void handlemap_VkVideoCodingControlInfoKHR(VulkanHandleMapping* handlemap,
 
 #endif
 #ifdef VK_KHR_video_decode_queue
+void handlemap_VkVideoDecodeCapabilitiesKHR(VulkanHandleMapping* handlemap,
+                                            VkVideoDecodeCapabilitiesKHR* toMap);
+
+void handlemap_VkVideoDecodeUsageInfoKHR(VulkanHandleMapping* handlemap,
+                                         VkVideoDecodeUsageInfoKHR* toMap);
+
 void handlemap_VkVideoDecodeInfoKHR(VulkanHandleMapping* handlemap, VkVideoDecodeInfoKHR* toMap);
 
 #endif
+#ifdef VK_KHR_video_decode_h264
+void handlemap_VkVideoDecodeH264ProfileInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkVideoDecodeH264ProfileInfoKHR* toMap);
+
+void handlemap_VkVideoDecodeH264CapabilitiesKHR(VulkanHandleMapping* handlemap,
+                                                VkVideoDecodeH264CapabilitiesKHR* toMap);
+
+void handlemap_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersAddInfoKHR* toMap);
+
+void handlemap_VkVideoDecodeH264SessionParametersCreateInfoKHR(
+    VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersCreateInfoKHR* toMap);
+
+void handlemap_VkVideoDecodeH264PictureInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkVideoDecodeH264PictureInfoKHR* toMap);
+
+void handlemap_VkVideoDecodeH264DpbSlotInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkVideoDecodeH264DpbSlotInfoKHR* toMap);
+
+#endif
 #ifdef VK_KHR_dynamic_rendering
-void handlemap_VkRenderingAttachmentInfoKHR(VulkanHandleMapping* handlemap,
-                                            VkRenderingAttachmentInfoKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkRenderingInfo, handlemap_VkRenderingInfoKHR)
 
-void handlemap_VkRenderingInfoKHR(VulkanHandleMapping* handlemap, VkRenderingInfoKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkRenderingAttachmentInfo, handlemap_VkRenderingAttachmentInfoKHR)
 
-void handlemap_VkPipelineRenderingCreateInfoKHR(VulkanHandleMapping* handlemap,
-                                                VkPipelineRenderingCreateInfoKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineRenderingCreateInfo,
+                      handlemap_VkPipelineRenderingCreateInfoKHR)
 
-void handlemap_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceDynamicRenderingFeaturesKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceDynamicRenderingFeatures,
+                      handlemap_VkPhysicalDeviceDynamicRenderingFeaturesKHR)
 
-void handlemap_VkCommandBufferInheritanceRenderingInfoKHR(
-    VulkanHandleMapping* handlemap, VkCommandBufferInheritanceRenderingInfoKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkCommandBufferInheritanceRenderingInfo,
+                      handlemap_VkCommandBufferInheritanceRenderingInfoKHR)
 
 void handlemap_VkRenderingFragmentShadingRateAttachmentInfoKHR(
     VulkanHandleMapping* handlemap, VkRenderingFragmentShadingRateAttachmentInfoKHR* toMap);
@@ -1269,6 +1444,37 @@ void handlemap_VkPhysicalDeviceShaderClockFeaturesKHR(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderClockFeaturesKHR* toMap);
 
 #endif
+#ifdef VK_KHR_video_decode_h265
+void handlemap_VkVideoDecodeH265ProfileInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkVideoDecodeH265ProfileInfoKHR* toMap);
+
+void handlemap_VkVideoDecodeH265CapabilitiesKHR(VulkanHandleMapping* handlemap,
+                                                VkVideoDecodeH265CapabilitiesKHR* toMap);
+
+void handlemap_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersAddInfoKHR* toMap);
+
+void handlemap_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersCreateInfoKHR* toMap);
+
+void handlemap_VkVideoDecodeH265PictureInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkVideoDecodeH265PictureInfoKHR* toMap);
+
+void handlemap_VkVideoDecodeH265DpbSlotInfoKHR(VulkanHandleMapping* handlemap,
+                                               VkVideoDecodeH265DpbSlotInfoKHR* toMap);
+
+#endif
+#ifdef VK_KHR_global_priority
+void handlemap_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    VulkanHandleMapping* handlemap, VkDeviceQueueGlobalPriorityCreateInfoKHR* toMap);
+
+void handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* toMap);
+
+void handlemap_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    VulkanHandleMapping* handlemap, VkQueueFamilyGlobalPriorityPropertiesKHR* toMap);
+
+#endif
 #ifdef VK_KHR_driver_properties
 DEFINE_ALIAS_FUNCTION(handlemap_VkConformanceVersion, handlemap_VkConformanceVersionKHR)
 
@@ -1314,8 +1520,8 @@ DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceVulkanMemoryModelFeatures,
 
 #endif
 #ifdef VK_KHR_shader_terminate_invocation
-void handlemap_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderTerminateInvocationFeatures,
+                      handlemap_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)
 
 #endif
 #ifdef VK_KHR_fragment_shading_rate
@@ -1403,12 +1609,18 @@ void handlemap_VkPipelineExecutableInternalRepresentationKHR(
     VulkanHandleMapping* handlemap, VkPipelineExecutableInternalRepresentationKHR* toMap);
 
 #endif
+#ifdef VK_KHR_map_memory2
+void handlemap_VkMemoryMapInfoKHR(VulkanHandleMapping* handlemap, VkMemoryMapInfoKHR* toMap);
+
+void handlemap_VkMemoryUnmapInfoKHR(VulkanHandleMapping* handlemap, VkMemoryUnmapInfoKHR* toMap);
+
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
-void handlemap_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderIntegerDotProductFeatures,
+                      handlemap_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR)
 
-void handlemap_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderIntegerDotProductProperties,
+                      handlemap_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)
 
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -1428,31 +1640,39 @@ void handlemap_VkPhysicalDevicePresentIdFeaturesKHR(VulkanHandleMapping* handlem
 #ifdef VK_KHR_video_encode_queue
 void handlemap_VkVideoEncodeInfoKHR(VulkanHandleMapping* handlemap, VkVideoEncodeInfoKHR* toMap);
 
+void handlemap_VkVideoEncodeCapabilitiesKHR(VulkanHandleMapping* handlemap,
+                                            VkVideoEncodeCapabilitiesKHR* toMap);
+
+void handlemap_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    VulkanHandleMapping* handlemap, VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* toMap);
+
+void handlemap_VkVideoEncodeUsageInfoKHR(VulkanHandleMapping* handlemap,
+                                         VkVideoEncodeUsageInfoKHR* toMap);
+
+void handlemap_VkVideoEncodeRateControlLayerInfoKHR(VulkanHandleMapping* handlemap,
+                                                    VkVideoEncodeRateControlLayerInfoKHR* toMap);
+
 void handlemap_VkVideoEncodeRateControlInfoKHR(VulkanHandleMapping* handlemap,
                                                VkVideoEncodeRateControlInfoKHR* toMap);
 
 #endif
 #ifdef VK_KHR_synchronization2
-void handlemap_VkMemoryBarrier2KHR(VulkanHandleMapping* handlemap, VkMemoryBarrier2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkMemoryBarrier2, handlemap_VkMemoryBarrier2KHR)
 
-void handlemap_VkBufferMemoryBarrier2KHR(VulkanHandleMapping* handlemap,
-                                         VkBufferMemoryBarrier2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkBufferMemoryBarrier2, handlemap_VkBufferMemoryBarrier2KHR)
 
-void handlemap_VkImageMemoryBarrier2KHR(VulkanHandleMapping* handlemap,
-                                        VkImageMemoryBarrier2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkImageMemoryBarrier2, handlemap_VkImageMemoryBarrier2KHR)
 
-void handlemap_VkDependencyInfoKHR(VulkanHandleMapping* handlemap, VkDependencyInfoKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkDependencyInfo, handlemap_VkDependencyInfoKHR)
 
-void handlemap_VkSemaphoreSubmitInfoKHR(VulkanHandleMapping* handlemap,
-                                        VkSemaphoreSubmitInfoKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkSubmitInfo2, handlemap_VkSubmitInfo2KHR)
 
-void handlemap_VkCommandBufferSubmitInfoKHR(VulkanHandleMapping* handlemap,
-                                            VkCommandBufferSubmitInfoKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkSemaphoreSubmitInfo, handlemap_VkSemaphoreSubmitInfoKHR)
 
-void handlemap_VkSubmitInfo2KHR(VulkanHandleMapping* handlemap, VkSubmitInfo2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkCommandBufferSubmitInfo, handlemap_VkCommandBufferSubmitInfoKHR)
 
-void handlemap_VkPhysicalDeviceSynchronization2FeaturesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceSynchronization2FeaturesKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSynchronization2Features,
+                      handlemap_VkPhysicalDeviceSynchronization2FeaturesKHR)
 
 void handlemap_VkQueueFamilyCheckpointProperties2NV(VulkanHandleMapping* handlemap,
                                                     VkQueueFamilyCheckpointProperties2NV* toMap);
@@ -1460,6 +1680,14 @@ void handlemap_VkQueueFamilyCheckpointProperties2NV(VulkanHandleMapping* handlem
 void handlemap_VkCheckpointData2NV(VulkanHandleMapping* handlemap, VkCheckpointData2NV* toMap);
 
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+void handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* toMap);
+
+void handlemap_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* toMap);
+
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 void handlemap_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
     VulkanHandleMapping* handlemap,
@@ -1467,9 +1695,8 @@ void handlemap_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
-void handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    VulkanHandleMapping* handlemap,
-    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
+                      handlemap_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR)
 
 #endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
@@ -1479,54 +1706,74 @@ void handlemap_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_copy_commands2
-void handlemap_VkBufferCopy2KHR(VulkanHandleMapping* handlemap, VkBufferCopy2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkCopyBufferInfo2, handlemap_VkCopyBufferInfo2KHR)
 
-void handlemap_VkCopyBufferInfo2KHR(VulkanHandleMapping* handlemap, VkCopyBufferInfo2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkCopyImageInfo2, handlemap_VkCopyImageInfo2KHR)
 
-void handlemap_VkImageCopy2KHR(VulkanHandleMapping* handlemap, VkImageCopy2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkCopyBufferToImageInfo2, handlemap_VkCopyBufferToImageInfo2KHR)
 
-void handlemap_VkCopyImageInfo2KHR(VulkanHandleMapping* handlemap, VkCopyImageInfo2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkCopyImageToBufferInfo2, handlemap_VkCopyImageToBufferInfo2KHR)
 
-void handlemap_VkBufferImageCopy2KHR(VulkanHandleMapping* handlemap, VkBufferImageCopy2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkBlitImageInfo2, handlemap_VkBlitImageInfo2KHR)
 
-void handlemap_VkCopyBufferToImageInfo2KHR(VulkanHandleMapping* handlemap,
-                                           VkCopyBufferToImageInfo2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkResolveImageInfo2, handlemap_VkResolveImageInfo2KHR)
 
-void handlemap_VkCopyImageToBufferInfo2KHR(VulkanHandleMapping* handlemap,
-                                           VkCopyImageToBufferInfo2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkBufferCopy2, handlemap_VkBufferCopy2KHR)
 
-void handlemap_VkImageBlit2KHR(VulkanHandleMapping* handlemap, VkImageBlit2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkImageCopy2, handlemap_VkImageCopy2KHR)
 
-void handlemap_VkBlitImageInfo2KHR(VulkanHandleMapping* handlemap, VkBlitImageInfo2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkImageBlit2, handlemap_VkImageBlit2KHR)
 
-void handlemap_VkImageResolve2KHR(VulkanHandleMapping* handlemap, VkImageResolve2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkBufferImageCopy2, handlemap_VkBufferImageCopy2KHR)
 
-void handlemap_VkResolveImageInfo2KHR(VulkanHandleMapping* handlemap,
-                                      VkResolveImageInfo2KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkImageResolve2, handlemap_VkImageResolve2KHR)
 
 #endif
 #ifdef VK_KHR_format_feature_flags2
-void handlemap_VkFormatProperties3KHR(VulkanHandleMapping* handlemap,
-                                      VkFormatProperties3KHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkFormatProperties3, handlemap_VkFormatProperties3KHR)
+
+#endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+void handlemap_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* toMap);
+
+void handlemap_VkTraceRaysIndirectCommand2KHR(VulkanHandleMapping* handlemap,
+                                              VkTraceRaysIndirectCommand2KHR* toMap);
 
 #endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
-void handlemap_VkPhysicalDeviceMaintenance4FeaturesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance4FeaturesKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMaintenance4Features,
+                      handlemap_VkPhysicalDeviceMaintenance4FeaturesKHR)
+
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMaintenance4Properties,
+                      handlemap_VkPhysicalDeviceMaintenance4PropertiesKHR)
 
-void handlemap_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceMaintenance4PropertiesKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceBufferMemoryRequirements,
+                      handlemap_VkDeviceBufferMemoryRequirementsKHR)
 
-void handlemap_VkDeviceBufferMemoryRequirementsKHR(VulkanHandleMapping* handlemap,
-                                                   VkDeviceBufferMemoryRequirementsKHR* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceImageMemoryRequirements,
+                      handlemap_VkDeviceImageMemoryRequirementsKHR)
 
-void handlemap_VkDeviceImageMemoryRequirementsKHR(VulkanHandleMapping* handlemap,
-                                                  VkDeviceImageMemoryRequirementsKHR* toMap);
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+void handlemap_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* toMap);
 
 #endif
 #ifdef VK_ANDROID_native_buffer
+void handlemap_VkNativeBufferUsage2ANDROID(VulkanHandleMapping* handlemap,
+                                           VkNativeBufferUsage2ANDROID* toMap);
+
 void handlemap_VkNativeBufferANDROID(VulkanHandleMapping* handlemap, VkNativeBufferANDROID* toMap);
 
+void handlemap_VkSwapchainImageCreateInfoANDROID(VulkanHandleMapping* handlemap,
+                                                 VkSwapchainImageCreateInfoANDROID* toMap);
+
+void handlemap_VkPhysicalDevicePresentationPropertiesANDROID(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePresentationPropertiesANDROID* toMap);
+
 #endif
 #ifdef VK_EXT_debug_report
 void handlemap_VkDebugReportCallbackCreateInfoEXT(VulkanHandleMapping* handlemap,
@@ -1613,87 +1860,70 @@ void handlemap_VkImageViewAddressPropertiesNVX(VulkanHandleMapping* handlemap,
 void handlemap_VkVideoEncodeH264CapabilitiesEXT(VulkanHandleMapping* handlemap,
                                                 VkVideoEncodeH264CapabilitiesEXT* toMap);
 
-void handlemap_VkVideoEncodeH264SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
-                                                     VkVideoEncodeH264SessionCreateInfoEXT* toMap);
-
 void handlemap_VkVideoEncodeH264SessionParametersAddInfoEXT(
     VulkanHandleMapping* handlemap, VkVideoEncodeH264SessionParametersAddInfoEXT* toMap);
 
 void handlemap_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkVideoEncodeH264SessionParametersCreateInfoEXT* toMap);
 
+void handlemap_VkVideoEncodeH264NaluSliceInfoEXT(VulkanHandleMapping* handlemap,
+                                                 VkVideoEncodeH264NaluSliceInfoEXT* toMap);
+
+void handlemap_VkVideoEncodeH264VclFrameInfoEXT(VulkanHandleMapping* handlemap,
+                                                VkVideoEncodeH264VclFrameInfoEXT* toMap);
+
 void handlemap_VkVideoEncodeH264DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
                                                VkVideoEncodeH264DpbSlotInfoEXT* toMap);
 
-void handlemap_VkVideoEncodeH264NaluSliceEXT(VulkanHandleMapping* handlemap,
-                                             VkVideoEncodeH264NaluSliceEXT* toMap);
+void handlemap_VkVideoEncodeH264ProfileInfoEXT(VulkanHandleMapping* handlemap,
+                                               VkVideoEncodeH264ProfileInfoEXT* toMap);
 
-void handlemap_VkVideoEncodeH264VclFrameInfoEXT(VulkanHandleMapping* handlemap,
-                                                VkVideoEncodeH264VclFrameInfoEXT* toMap);
+void handlemap_VkVideoEncodeH264RateControlInfoEXT(VulkanHandleMapping* handlemap,
+                                                   VkVideoEncodeH264RateControlInfoEXT* toMap);
+
+void handlemap_VkVideoEncodeH264QpEXT(VulkanHandleMapping* handlemap,
+                                      VkVideoEncodeH264QpEXT* toMap);
 
-void handlemap_VkVideoEncodeH264EmitPictureParametersEXT(
-    VulkanHandleMapping* handlemap, VkVideoEncodeH264EmitPictureParametersEXT* toMap);
+void handlemap_VkVideoEncodeH264FrameSizeEXT(VulkanHandleMapping* handlemap,
+                                             VkVideoEncodeH264FrameSizeEXT* toMap);
 
-void handlemap_VkVideoEncodeH264ProfileEXT(VulkanHandleMapping* handlemap,
-                                           VkVideoEncodeH264ProfileEXT* toMap);
+void handlemap_VkVideoEncodeH264RateControlLayerInfoEXT(
+    VulkanHandleMapping* handlemap, VkVideoEncodeH264RateControlLayerInfoEXT* toMap);
 
 #endif
 #ifdef VK_EXT_video_encode_h265
 void handlemap_VkVideoEncodeH265CapabilitiesEXT(VulkanHandleMapping* handlemap,
                                                 VkVideoEncodeH265CapabilitiesEXT* toMap);
 
-void handlemap_VkVideoEncodeH265SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
-                                                     VkVideoEncodeH265SessionCreateInfoEXT* toMap);
-
 void handlemap_VkVideoEncodeH265SessionParametersAddInfoEXT(
     VulkanHandleMapping* handlemap, VkVideoEncodeH265SessionParametersAddInfoEXT* toMap);
 
 void handlemap_VkVideoEncodeH265SessionParametersCreateInfoEXT(
     VulkanHandleMapping* handlemap, VkVideoEncodeH265SessionParametersCreateInfoEXT* toMap);
 
-void handlemap_VkVideoEncodeH265DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
-                                               VkVideoEncodeH265DpbSlotInfoEXT* toMap);
-
-void handlemap_VkVideoEncodeH265ReferenceListsEXT(VulkanHandleMapping* handlemap,
-                                                  VkVideoEncodeH265ReferenceListsEXT* toMap);
-
-void handlemap_VkVideoEncodeH265NaluSliceEXT(VulkanHandleMapping* handlemap,
-                                             VkVideoEncodeH265NaluSliceEXT* toMap);
+void handlemap_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+    VulkanHandleMapping* handlemap, VkVideoEncodeH265NaluSliceSegmentInfoEXT* toMap);
 
 void handlemap_VkVideoEncodeH265VclFrameInfoEXT(VulkanHandleMapping* handlemap,
                                                 VkVideoEncodeH265VclFrameInfoEXT* toMap);
 
-void handlemap_VkVideoEncodeH265EmitPictureParametersEXT(
-    VulkanHandleMapping* handlemap, VkVideoEncodeH265EmitPictureParametersEXT* toMap);
-
-void handlemap_VkVideoEncodeH265ProfileEXT(VulkanHandleMapping* handlemap,
-                                           VkVideoEncodeH265ProfileEXT* toMap);
-
-#endif
-#ifdef VK_EXT_video_decode_h264
-void handlemap_VkVideoDecodeH264ProfileEXT(VulkanHandleMapping* handlemap,
-                                           VkVideoDecodeH264ProfileEXT* toMap);
-
-void handlemap_VkVideoDecodeH264CapabilitiesEXT(VulkanHandleMapping* handlemap,
-                                                VkVideoDecodeH264CapabilitiesEXT* toMap);
-
-void handlemap_VkVideoDecodeH264SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
-                                                     VkVideoDecodeH264SessionCreateInfoEXT* toMap);
+void handlemap_VkVideoEncodeH265DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
+                                               VkVideoEncodeH265DpbSlotInfoEXT* toMap);
 
-void handlemap_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersAddInfoEXT* toMap);
+void handlemap_VkVideoEncodeH265ProfileInfoEXT(VulkanHandleMapping* handlemap,
+                                               VkVideoEncodeH265ProfileInfoEXT* toMap);
 
-void handlemap_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-    VulkanHandleMapping* handlemap, VkVideoDecodeH264SessionParametersCreateInfoEXT* toMap);
+void handlemap_VkVideoEncodeH265RateControlInfoEXT(VulkanHandleMapping* handlemap,
+                                                   VkVideoEncodeH265RateControlInfoEXT* toMap);
 
-void handlemap_VkVideoDecodeH264PictureInfoEXT(VulkanHandleMapping* handlemap,
-                                               VkVideoDecodeH264PictureInfoEXT* toMap);
+void handlemap_VkVideoEncodeH265QpEXT(VulkanHandleMapping* handlemap,
+                                      VkVideoEncodeH265QpEXT* toMap);
 
-void handlemap_VkVideoDecodeH264MvcEXT(VulkanHandleMapping* handlemap,
-                                       VkVideoDecodeH264MvcEXT* toMap);
+void handlemap_VkVideoEncodeH265FrameSizeEXT(VulkanHandleMapping* handlemap,
+                                             VkVideoEncodeH265FrameSizeEXT* toMap);
 
-void handlemap_VkVideoDecodeH264DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
-                                               VkVideoDecodeH264DpbSlotInfoEXT* toMap);
+void handlemap_VkVideoEncodeH265RateControlLayerInfoEXT(
+    VulkanHandleMapping* handlemap, VkVideoEncodeH265RateControlLayerInfoEXT* toMap);
 
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
@@ -1763,8 +1993,8 @@ void handlemap_VkViSurfaceCreateInfoNN(VulkanHandleMapping* handlemap,
 #ifdef VK_EXT_shader_subgroup_vote
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
-void handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeatures,
+                      handlemap_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
 
 #endif
 #ifdef VK_EXT_astc_decode_mode
@@ -1775,6 +2005,17 @@ void handlemap_VkPhysicalDeviceASTCDecodeFeaturesEXT(VulkanHandleMapping* handle
                                                      VkPhysicalDeviceASTCDecodeFeaturesEXT* toMap);
 
 #endif
+#ifdef VK_EXT_pipeline_robustness
+void handlemap_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineRobustnessFeaturesEXT* toMap);
+
+void handlemap_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineRobustnessPropertiesEXT* toMap);
+
+void handlemap_VkPipelineRobustnessCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                                 VkPipelineRobustnessCreateInfoEXT* toMap);
+
+#endif
 #ifdef VK_EXT_conditional_rendering
 void handlemap_VkConditionalRenderingBeginInfoEXT(VulkanHandleMapping* handlemap,
                                                   VkConditionalRenderingBeginInfoEXT* toMap);
@@ -1886,8 +2127,6 @@ void handlemap_VkMacOSSurfaceCreateInfoMVK(VulkanHandleMapping* handlemap,
                                            VkMacOSSurfaceCreateInfoMVK* toMap);
 
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -1946,17 +2185,17 @@ DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSamplerFilterMinmaxProperties,
 #ifdef VK_AMD_shader_fragment_mask
 #endif
 #ifdef VK_EXT_inline_uniform_block
-void handlemap_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceInlineUniformBlockFeatures,
+                      handlemap_VkPhysicalDeviceInlineUniformBlockFeaturesEXT)
 
-void handlemap_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceInlineUniformBlockProperties,
+                      handlemap_VkPhysicalDeviceInlineUniformBlockPropertiesEXT)
 
-void handlemap_VkWriteDescriptorSetInlineUniformBlockEXT(
-    VulkanHandleMapping* handlemap, VkWriteDescriptorSetInlineUniformBlockEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkWriteDescriptorSetInlineUniformBlock,
+                      handlemap_VkWriteDescriptorSetInlineUniformBlockEXT)
 
-void handlemap_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    VulkanHandleMapping* handlemap, VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkDescriptorPoolInlineUniformBlockCreateInfo,
+                      handlemap_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_shader_stencil_export
@@ -2162,8 +2401,8 @@ void handlemap_VkFilterCubicImageViewImageFormatPropertiesEXT(
 #ifdef VK_QCOM_render_pass_shader_resolve
 #endif
 #ifdef VK_EXT_global_priority
-void handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    VulkanHandleMapping* handlemap, VkDeviceQueueGlobalPriorityCreateInfoEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkDeviceQueueGlobalPriorityCreateInfoKHR,
+                      handlemap_VkDeviceQueueGlobalPriorityCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_external_memory_host
@@ -2194,29 +2433,6 @@ void handlemap_VkPhysicalDeviceShaderCorePropertiesAMD(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCorePropertiesAMD* toMap);
 
 #endif
-#ifdef VK_EXT_video_decode_h265
-void handlemap_VkVideoDecodeH265ProfileEXT(VulkanHandleMapping* handlemap,
-                                           VkVideoDecodeH265ProfileEXT* toMap);
-
-void handlemap_VkVideoDecodeH265CapabilitiesEXT(VulkanHandleMapping* handlemap,
-                                                VkVideoDecodeH265CapabilitiesEXT* toMap);
-
-void handlemap_VkVideoDecodeH265SessionCreateInfoEXT(VulkanHandleMapping* handlemap,
-                                                     VkVideoDecodeH265SessionCreateInfoEXT* toMap);
-
-void handlemap_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersAddInfoEXT* toMap);
-
-void handlemap_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    VulkanHandleMapping* handlemap, VkVideoDecodeH265SessionParametersCreateInfoEXT* toMap);
-
-void handlemap_VkVideoDecodeH265PictureInfoEXT(VulkanHandleMapping* handlemap,
-                                               VkVideoDecodeH265PictureInfoEXT* toMap);
-
-void handlemap_VkVideoDecodeH265DpbSlotInfoEXT(VulkanHandleMapping* handlemap,
-                                               VkVideoDecodeH265DpbSlotInfoEXT* toMap);
-
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 void handlemap_VkDeviceMemoryOverallocationCreateInfoAMD(
     VulkanHandleMapping* handlemap, VkDeviceMemoryOverallocationCreateInfoAMD* toMap);
@@ -2242,11 +2458,10 @@ void handlemap_VkPresentFrameTokenGGP(VulkanHandleMapping* handlemap,
 
 #endif
 #ifdef VK_EXT_pipeline_creation_feedback
-void handlemap_VkPipelineCreationFeedbackEXT(VulkanHandleMapping* handlemap,
-                                             VkPipelineCreationFeedbackEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineCreationFeedbackCreateInfo,
+                      handlemap_VkPipelineCreationFeedbackCreateInfoEXT)
 
-void handlemap_VkPipelineCreationFeedbackCreateInfoEXT(
-    VulkanHandleMapping* handlemap, VkPipelineCreationFeedbackCreateInfoEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineCreationFeedback, handlemap_VkPipelineCreationFeedbackEXT)
 
 #endif
 #ifdef VK_NV_shader_subgroup_partitioned
@@ -2268,8 +2483,8 @@ void handlemap_VkDrawMeshTasksIndirectCommandNV(VulkanHandleMapping* handlemap,
 
 #endif
 #ifdef VK_NV_fragment_shader_barycentric
-void handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
+                      handlemap_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV)
 
 #endif
 #ifdef VK_NV_shader_image_footprint
@@ -2370,14 +2585,14 @@ DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceScalarBlockLayoutFeatures,
 #ifdef VK_GOOGLE_decorate_string
 #endif
 #ifdef VK_EXT_subgroup_size_control
-void handlemap_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSubgroupSizeControlFeatures,
+                      handlemap_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)
 
-void handlemap_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceSubgroupSizeControlProperties,
+                      handlemap_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT)
 
-void handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    VulkanHandleMapping* handlemap, VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)
 
 #endif
 #ifdef VK_AMD_shader_core_properties2
@@ -2428,8 +2643,8 @@ void handlemap_VkBufferDeviceAddressCreateInfoEXT(VulkanHandleMapping* handlemap
 
 #endif
 #ifdef VK_EXT_tooling_info
-void handlemap_VkPhysicalDeviceToolPropertiesEXT(VulkanHandleMapping* handlemap,
-                                                 VkPhysicalDeviceToolPropertiesEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceToolProperties,
+                      handlemap_VkPhysicalDeviceToolPropertiesEXT)
 
 #endif
 #ifdef VK_EXT_separate_stencil_usage
@@ -2538,10 +2753,40 @@ void handlemap_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toMap);
 
 #endif
+#ifdef VK_EXT_surface_maintenance1
+void handlemap_VkSurfacePresentModeEXT(VulkanHandleMapping* handlemap,
+                                       VkSurfacePresentModeEXT* toMap);
+
+void handlemap_VkSurfacePresentScalingCapabilitiesEXT(
+    VulkanHandleMapping* handlemap, VkSurfacePresentScalingCapabilitiesEXT* toMap);
+
+void handlemap_VkSurfacePresentModeCompatibilityEXT(VulkanHandleMapping* handlemap,
+                                                    VkSurfacePresentModeCompatibilityEXT* toMap);
+
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+void handlemap_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* toMap);
+
+void handlemap_VkSwapchainPresentFenceInfoEXT(VulkanHandleMapping* handlemap,
+                                              VkSwapchainPresentFenceInfoEXT* toMap);
+
+void handlemap_VkSwapchainPresentModesCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                                    VkSwapchainPresentModesCreateInfoEXT* toMap);
+
+void handlemap_VkSwapchainPresentModeInfoEXT(VulkanHandleMapping* handlemap,
+                                             VkSwapchainPresentModeInfoEXT* toMap);
+
+void handlemap_VkSwapchainPresentScalingCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkSwapchainPresentScalingCreateInfoEXT* toMap);
+
+void handlemap_VkReleaseSwapchainImagesInfoEXT(VulkanHandleMapping* handlemap,
+                                               VkReleaseSwapchainImagesInfoEXT* toMap);
+
+#endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
-void handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
-    VulkanHandleMapping* handlemap,
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures,
+                      handlemap_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)
 
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -2597,8 +2842,8 @@ void handlemap_VkCommandBufferInheritanceViewportScissorInfoNV(
 void handlemap_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toMap);
 
-void handlemap_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceTexelBufferAlignmentProperties,
+                      handlemap_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)
 
 #endif
 #ifdef VK_QCOM_render_pass_transform
@@ -2643,20 +2888,31 @@ void handlemap_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+void handlemap_VkPhysicalDevicePresentBarrierFeaturesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePresentBarrierFeaturesNV* toMap);
+
+void handlemap_VkSurfaceCapabilitiesPresentBarrierNV(VulkanHandleMapping* handlemap,
+                                                     VkSurfaceCapabilitiesPresentBarrierNV* toMap);
+
+void handlemap_VkSwapchainPresentBarrierCreateInfoNV(VulkanHandleMapping* handlemap,
+                                                     VkSwapchainPresentBarrierCreateInfoNV* toMap);
+
+#endif
 #ifdef VK_EXT_private_data
-void handlemap_VkPhysicalDevicePrivateDataFeaturesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDevicePrivateDataFeaturesEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDevicePrivateDataFeatures,
+                      handlemap_VkPhysicalDevicePrivateDataFeaturesEXT)
 
-void handlemap_VkDevicePrivateDataCreateInfoEXT(VulkanHandleMapping* handlemap,
-                                                VkDevicePrivateDataCreateInfoEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkDevicePrivateDataCreateInfo,
+                      handlemap_VkDevicePrivateDataCreateInfoEXT)
 
-void handlemap_VkPrivateDataSlotCreateInfoEXT(VulkanHandleMapping* handlemap,
-                                              VkPrivateDataSlotCreateInfoEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPrivateDataSlotCreateInfo,
+                      handlemap_VkPrivateDataSlotCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
-void handlemap_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDevicePipelineCreationCacheControlFeatures,
+                      handlemap_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT)
 
 #endif
 #ifdef VK_NV_device_diagnostics_config
@@ -2669,6 +2925,109 @@ void handlemap_VkDeviceDiagnosticsConfigCreateInfoNV(VulkanHandleMapping* handle
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+void handlemap_VkQueryLowLatencySupportNV(VulkanHandleMapping* handlemap,
+                                          VkQueryLowLatencySupportNV* toMap);
+
+#endif
+#ifdef VK_EXT_metal_objects
+void handlemap_VkExportMetalObjectCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                                VkExportMetalObjectCreateInfoEXT* toMap);
+
+void handlemap_VkExportMetalObjectsInfoEXT(VulkanHandleMapping* handlemap,
+                                           VkExportMetalObjectsInfoEXT* toMap);
+
+void handlemap_VkExportMetalDeviceInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkExportMetalDeviceInfoEXT* toMap);
+
+void handlemap_VkExportMetalCommandQueueInfoEXT(VulkanHandleMapping* handlemap,
+                                                VkExportMetalCommandQueueInfoEXT* toMap);
+
+void handlemap_VkExportMetalBufferInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkExportMetalBufferInfoEXT* toMap);
+
+void handlemap_VkImportMetalBufferInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkImportMetalBufferInfoEXT* toMap);
+
+void handlemap_VkExportMetalTextureInfoEXT(VulkanHandleMapping* handlemap,
+                                           VkExportMetalTextureInfoEXT* toMap);
+
+void handlemap_VkImportMetalTextureInfoEXT(VulkanHandleMapping* handlemap,
+                                           VkImportMetalTextureInfoEXT* toMap);
+
+void handlemap_VkExportMetalIOSurfaceInfoEXT(VulkanHandleMapping* handlemap,
+                                             VkExportMetalIOSurfaceInfoEXT* toMap);
+
+void handlemap_VkImportMetalIOSurfaceInfoEXT(VulkanHandleMapping* handlemap,
+                                             VkImportMetalIOSurfaceInfoEXT* toMap);
+
+void handlemap_VkExportMetalSharedEventInfoEXT(VulkanHandleMapping* handlemap,
+                                               VkExportMetalSharedEventInfoEXT* toMap);
+
+void handlemap_VkImportMetalSharedEventInfoEXT(VulkanHandleMapping* handlemap,
+                                               VkImportMetalSharedEventInfoEXT* toMap);
+
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void handlemap_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorBufferPropertiesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorBufferFeaturesEXT* toMap);
+
+void handlemap_VkDescriptorAddressInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkDescriptorAddressInfoEXT* toMap);
+
+void handlemap_VkDescriptorBufferBindingInfoEXT(VulkanHandleMapping* handlemap,
+                                                VkDescriptorBufferBindingInfoEXT* toMap);
+
+void handlemap_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    VulkanHandleMapping* handlemap, VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* toMap);
+
+void handlemap_VkDescriptorDataEXT(VulkanHandleMapping* handlemap, VkDescriptorDataEXT* toMap);
+
+void handlemap_VkDescriptorGetInfoEXT(VulkanHandleMapping* handlemap,
+                                      VkDescriptorGetInfoEXT* toMap);
+
+void handlemap_VkBufferCaptureDescriptorDataInfoEXT(VulkanHandleMapping* handlemap,
+                                                    VkBufferCaptureDescriptorDataInfoEXT* toMap);
+
+void handlemap_VkImageCaptureDescriptorDataInfoEXT(VulkanHandleMapping* handlemap,
+                                                   VkImageCaptureDescriptorDataInfoEXT* toMap);
+
+void handlemap_VkImageViewCaptureDescriptorDataInfoEXT(
+    VulkanHandleMapping* handlemap, VkImageViewCaptureDescriptorDataInfoEXT* toMap);
+
+void handlemap_VkSamplerCaptureDescriptorDataInfoEXT(VulkanHandleMapping* handlemap,
+                                                     VkSamplerCaptureDescriptorDataInfoEXT* toMap);
+
+void handlemap_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkOpaqueCaptureDescriptorDataCreateInfoEXT* toMap);
+
+void handlemap_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    VulkanHandleMapping* handlemap, VkAccelerationStructureCaptureDescriptorDataInfoEXT* toMap);
+
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+void handlemap_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* toMap);
+
+void handlemap_VkGraphicsPipelineLibraryCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkGraphicsPipelineLibraryCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+void handlemap_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* toMap);
+
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void handlemap_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* toMap);
@@ -2727,8 +3086,30 @@ void handlemap_VkCopyCommandTransformInfoQCOM(VulkanHandleMapping* handlemap,
 
 #endif
 #ifdef VK_EXT_image_robustness
-void handlemap_VkPhysicalDeviceImageRobustnessFeaturesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageRobustnessFeaturesEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceImageRobustnessFeatures,
+                      handlemap_VkPhysicalDeviceImageRobustnessFeaturesEXT)
+
+#endif
+#ifdef VK_EXT_image_compression_control
+void handlemap_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageCompressionControlFeaturesEXT* toMap);
+
+void handlemap_VkImageCompressionControlEXT(VulkanHandleMapping* handlemap,
+                                            VkImageCompressionControlEXT* toMap);
+
+void handlemap_VkSubresourceLayout2EXT(VulkanHandleMapping* handlemap,
+                                       VkSubresourceLayout2EXT* toMap);
+
+void handlemap_VkImageSubresource2EXT(VulkanHandleMapping* handlemap,
+                                      VkImageSubresource2EXT* toMap);
+
+void handlemap_VkImageCompressionPropertiesEXT(VulkanHandleMapping* handlemap,
+                                               VkImageCompressionPropertiesEXT* toMap);
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+void handlemap_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* toMap);
 
 #endif
 #ifdef VK_EXT_4444_formats
@@ -2736,6 +3117,34 @@ void handlemap_VkPhysicalDevice4444FormatsFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDevice4444FormatsFeaturesEXT* toMap);
 
 #endif
+#ifdef VK_EXT_device_fault
+void handlemap_VkPhysicalDeviceFaultFeaturesEXT(VulkanHandleMapping* handlemap,
+                                                VkPhysicalDeviceFaultFeaturesEXT* toMap);
+
+void handlemap_VkDeviceFaultCountsEXT(VulkanHandleMapping* handlemap,
+                                      VkDeviceFaultCountsEXT* toMap);
+
+void handlemap_VkDeviceFaultAddressInfoEXT(VulkanHandleMapping* handlemap,
+                                           VkDeviceFaultAddressInfoEXT* toMap);
+
+void handlemap_VkDeviceFaultVendorInfoEXT(VulkanHandleMapping* handlemap,
+                                          VkDeviceFaultVendorInfoEXT* toMap);
+
+void handlemap_VkDeviceFaultInfoEXT(VulkanHandleMapping* handlemap, VkDeviceFaultInfoEXT* toMap);
+
+void handlemap_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    VulkanHandleMapping* handlemap, VkDeviceFaultVendorBinaryHeaderVersionOneEXT* toMap);
+
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+void handlemap_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* toMap);
+
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
+                      handlemap_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM)
+
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 void handlemap_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toMap);
@@ -2749,14 +3158,23 @@ void handlemap_VkDirectFBSurfaceCreateInfoEXT(VulkanHandleMapping* handlemap,
 
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-void handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toMap);
+void handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* toMap);
+
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT,
+                      handlemap_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)
 
-void handlemap_VkMutableDescriptorTypeListVALVE(VulkanHandleMapping* handlemap,
-                                                VkMutableDescriptorTypeListVALVE* toMap);
+void handlemap_VkMutableDescriptorTypeListEXT(VulkanHandleMapping* handlemap,
+                                              VkMutableDescriptorTypeListEXT* toMap);
 
-void handlemap_VkMutableDescriptorTypeCreateInfoVALVE(
-    VulkanHandleMapping* handlemap, VkMutableDescriptorTypeCreateInfoVALVE* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkMutableDescriptorTypeListEXT,
+                      handlemap_VkMutableDescriptorTypeListVALVE)
+
+void handlemap_VkMutableDescriptorTypeCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                                    VkMutableDescriptorTypeCreateInfoEXT* toMap);
+
+DEFINE_ALIAS_FUNCTION(handlemap_VkMutableDescriptorTypeCreateInfoEXT,
+                      handlemap_VkMutableDescriptorTypeCreateInfoVALVE)
 
 #endif
 #ifdef VK_EXT_vertex_input_dynamic_state
@@ -2775,6 +3193,22 @@ void handlemap_VkPhysicalDeviceDrmPropertiesEXT(VulkanHandleMapping* handlemap,
                                                 VkPhysicalDeviceDrmPropertiesEXT* toMap);
 
 #endif
+#ifdef VK_EXT_device_address_binding_report
+void handlemap_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceAddressBindingReportFeaturesEXT* toMap);
+
+void handlemap_VkDeviceAddressBindingCallbackDataEXT(VulkanHandleMapping* handlemap,
+                                                     VkDeviceAddressBindingCallbackDataEXT* toMap);
+
+#endif
+#ifdef VK_EXT_depth_clip_control
+void handlemap_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthClipControlFeaturesEXT* toMap);
+
+void handlemap_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkPipelineViewportDepthClipControlCreateInfoEXT* toMap);
+
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 void handlemap_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* toMap);
@@ -2855,6 +3289,28 @@ void handlemap_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toMap);
 
 #endif
+#ifdef VK_EXT_pipeline_properties
+DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineInfoKHR, handlemap_VkPipelineInfoEXT)
+
+void handlemap_VkPipelinePropertiesIdentifierEXT(VulkanHandleMapping* handlemap,
+                                                 VkPipelinePropertiesIdentifierEXT* toMap);
+
+void handlemap_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelinePropertiesFeaturesEXT* toMap);
+
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+void handlemap_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* toMap);
+
+void handlemap_VkSubpassResolvePerformanceQueryEXT(VulkanHandleMapping* handlemap,
+                                                   VkSubpassResolvePerformanceQueryEXT* toMap);
+
+void handlemap_VkMultisampledRenderToSingleSampledInfoEXT(
+    VulkanHandleMapping* handlemap, VkMultisampledRenderToSingleSampledInfoEXT* toMap);
+
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void handlemap_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* toMap);
@@ -2873,6 +3329,11 @@ void handlemap_VkPipelineColorWriteCreateInfoEXT(VulkanHandleMapping* handlemap,
                                                  VkPipelineColorWriteCreateInfoEXT* toMap);
 
 #endif
+#ifdef VK_EXT_primitives_generated_query
+void handlemap_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* toMap);
+
+#endif
 #ifdef VK_GOOGLE_gfxstream
 void handlemap_VkImportColorBufferGOOGLE(VulkanHandleMapping* handlemap,
                                          VkImportColorBufferGOOGLE* toMap);
@@ -2883,11 +3344,19 @@ void handlemap_VkCreateBlobGOOGLE(VulkanHandleMapping* handlemap, VkCreateBlobGO
 
 #endif
 #ifdef VK_EXT_global_priority_query
-void handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
-    VulkanHandleMapping* handlemap, VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toMap);
+DEFINE_ALIAS_FUNCTION(handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR,
+                      handlemap_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT)
+
+DEFINE_ALIAS_FUNCTION(handlemap_VkQueueFamilyGlobalPriorityPropertiesKHR,
+                      handlemap_VkQueueFamilyGlobalPriorityPropertiesEXT)
+
+#endif
+#ifdef VK_EXT_image_view_min_lod
+void handlemap_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageViewMinLodFeaturesEXT* toMap);
 
-void handlemap_VkQueueFamilyGlobalPriorityPropertiesEXT(
-    VulkanHandleMapping* handlemap, VkQueueFamilyGlobalPriorityPropertiesEXT* toMap);
+void handlemap_VkImageViewMinLodCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                              VkImageViewMinLodCreateInfoEXT* toMap);
 
 #endif
 #ifdef VK_EXT_multi_draw
@@ -2903,8 +3372,78 @@ void handlemap_VkMultiDrawIndexedInfoEXT(VulkanHandleMapping* handlemap,
                                          VkMultiDrawIndexedInfoEXT* toMap);
 
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+void handlemap_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* toMap);
+
+#endif
+#ifdef VK_EXT_shader_tile_image
+void handlemap_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTileImageFeaturesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderTileImagePropertiesEXT* toMap);
+
+#endif
+#ifdef VK_EXT_opacity_micromap
+void handlemap_VkMicromapUsageEXT(VulkanHandleMapping* handlemap, VkMicromapUsageEXT* toMap);
+
+void handlemap_VkDeviceOrHostAddressKHR(VulkanHandleMapping* handlemap,
+                                        VkDeviceOrHostAddressKHR* toMap);
+
+void handlemap_VkMicromapBuildInfoEXT(VulkanHandleMapping* handlemap,
+                                      VkMicromapBuildInfoEXT* toMap);
+
+void handlemap_VkMicromapCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                       VkMicromapCreateInfoEXT* toMap);
+
+void handlemap_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceOpacityMicromapFeaturesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceOpacityMicromapPropertiesEXT* toMap);
+
+void handlemap_VkMicromapVersionInfoEXT(VulkanHandleMapping* handlemap,
+                                        VkMicromapVersionInfoEXT* toMap);
+
+void handlemap_VkCopyMicromapToMemoryInfoEXT(VulkanHandleMapping* handlemap,
+                                             VkCopyMicromapToMemoryInfoEXT* toMap);
+
+void handlemap_VkCopyMemoryToMicromapInfoEXT(VulkanHandleMapping* handlemap,
+                                             VkCopyMemoryToMicromapInfoEXT* toMap);
+
+void handlemap_VkCopyMicromapInfoEXT(VulkanHandleMapping* handlemap, VkCopyMicromapInfoEXT* toMap);
+
+void handlemap_VkMicromapBuildSizesInfoEXT(VulkanHandleMapping* handlemap,
+                                           VkMicromapBuildSizesInfoEXT* toMap);
+
+void handlemap_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    VulkanHandleMapping* handlemap, VkAccelerationStructureTrianglesOpacityMicromapEXT* toMap);
+
+void handlemap_VkMicromapTriangleEXT(VulkanHandleMapping* handlemap, VkMicromapTriangleEXT* toMap);
+
+#endif
+#ifdef VK_NV_displacement_micromap
+void handlemap_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDisplacementMicromapFeaturesNV* toMap);
+
+void handlemap_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDisplacementMicromapPropertiesNV* toMap);
+
+void handlemap_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    VulkanHandleMapping* handlemap, VkAccelerationStructureTrianglesDisplacementMicromapNV* toMap);
+
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void handlemap_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* toMap);
+
+void handlemap_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* toMap);
+
+#endif
 #ifdef VK_EXT_border_color_swizzle
 void handlemap_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* toMap);
@@ -2918,10 +3457,262 @@ void handlemap_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
     VulkanHandleMapping* handlemap, VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toMap);
 
 #endif
-#ifdef VK_KHR_acceleration_structure
-void handlemap_VkDeviceOrHostAddressKHR(VulkanHandleMapping* handlemap,
-                                        VkDeviceOrHostAddressKHR* toMap);
+#ifdef VK_ARM_shader_core_properties
+void handlemap_VkPhysicalDeviceShaderCorePropertiesARM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCorePropertiesARM* toMap);
+
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+void handlemap_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* toMap);
+
+void handlemap_VkImageViewSlicedCreateInfoEXT(VulkanHandleMapping* handlemap,
+                                              VkImageViewSlicedCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void handlemap_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* toMap);
+
+void handlemap_VkDescriptorSetBindingReferenceVALVE(VulkanHandleMapping* handlemap,
+                                                    VkDescriptorSetBindingReferenceVALVE* toMap);
+
+void handlemap_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    VulkanHandleMapping* handlemap, VkDescriptorSetLayoutHostMappingInfoVALVE* toMap);
+
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+void handlemap_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* toMap);
+
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+void handlemap_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* toMap);
+
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+void handlemap_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* toMap);
 
+void handlemap_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* toMap);
+
+void handlemap_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    VulkanHandleMapping* handlemap, VkSubpassFragmentDensityMapOffsetEndInfoQCOM* toMap);
+
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void handlemap_VkCopyMemoryIndirectCommandNV(VulkanHandleMapping* handlemap,
+                                             VkCopyMemoryIndirectCommandNV* toMap);
+
+void handlemap_VkCopyMemoryToImageIndirectCommandNV(VulkanHandleMapping* handlemap,
+                                                    VkCopyMemoryToImageIndirectCommandNV* toMap);
+
+void handlemap_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* toMap);
+
+void handlemap_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* toMap);
+
+#endif
+#ifdef VK_NV_memory_decompression
+void handlemap_VkDecompressMemoryRegionNV(VulkanHandleMapping* handlemap,
+                                          VkDecompressMemoryRegionNV* toMap);
+
+void handlemap_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMemoryDecompressionFeaturesNV* toMap);
+
+void handlemap_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMemoryDecompressionPropertiesNV* toMap);
+
+#endif
+#ifdef VK_NV_linear_color_attachment
+void handlemap_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceLinearColorAttachmentFeaturesNV* toMap);
+
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+void handlemap_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toMap);
+
+#endif
+#ifdef VK_QCOM_image_processing
+void handlemap_VkImageViewSampleWeightCreateInfoQCOM(VulkanHandleMapping* handlemap,
+                                                     VkImageViewSampleWeightCreateInfoQCOM* toMap);
+
+void handlemap_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageProcessingFeaturesQCOM* toMap);
+
+void handlemap_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceImageProcessingPropertiesQCOM* toMap);
+
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void handlemap_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* toMap);
+
+void handlemap_VkColorBlendEquationEXT(VulkanHandleMapping* handlemap,
+                                       VkColorBlendEquationEXT* toMap);
+
+void handlemap_VkColorBlendAdvancedEXT(VulkanHandleMapping* handlemap,
+                                       VkColorBlendAdvancedEXT* toMap);
+
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+void handlemap_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* toMap);
+
+void handlemap_VkRenderPassCreationControlEXT(VulkanHandleMapping* handlemap,
+                                              VkRenderPassCreationControlEXT* toMap);
+
+void handlemap_VkRenderPassCreationFeedbackInfoEXT(VulkanHandleMapping* handlemap,
+                                                   VkRenderPassCreationFeedbackInfoEXT* toMap);
+
+void handlemap_VkRenderPassCreationFeedbackCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkRenderPassCreationFeedbackCreateInfoEXT* toMap);
+
+void handlemap_VkRenderPassSubpassFeedbackInfoEXT(VulkanHandleMapping* handlemap,
+                                                  VkRenderPassSubpassFeedbackInfoEXT* toMap);
+
+void handlemap_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkRenderPassSubpassFeedbackCreateInfoEXT* toMap);
+
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+void handlemap_VkDirectDriverLoadingInfoLUNARG(VulkanHandleMapping* handlemap,
+                                               VkDirectDriverLoadingInfoLUNARG* toMap);
+
+void handlemap_VkDirectDriverLoadingListLUNARG(VulkanHandleMapping* handlemap,
+                                               VkDirectDriverLoadingListLUNARG* toMap);
+
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void handlemap_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* toMap);
+
+void handlemap_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    VulkanHandleMapping* handlemap, VkPipelineShaderStageModuleIdentifierCreateInfoEXT* toMap);
+
+void handlemap_VkShaderModuleIdentifierEXT(VulkanHandleMapping* handlemap,
+                                           VkShaderModuleIdentifierEXT* toMap);
+
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+void handlemap_VkPhysicalDeviceOpticalFlowFeaturesNV(VulkanHandleMapping* handlemap,
+                                                     VkPhysicalDeviceOpticalFlowFeaturesNV* toMap);
+
+void handlemap_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceOpticalFlowPropertiesNV* toMap);
+
+void handlemap_VkOpticalFlowImageFormatInfoNV(VulkanHandleMapping* handlemap,
+                                              VkOpticalFlowImageFormatInfoNV* toMap);
+
+void handlemap_VkOpticalFlowImageFormatPropertiesNV(VulkanHandleMapping* handlemap,
+                                                    VkOpticalFlowImageFormatPropertiesNV* toMap);
+
+void handlemap_VkOpticalFlowSessionCreateInfoNV(VulkanHandleMapping* handlemap,
+                                                VkOpticalFlowSessionCreateInfoNV* toMap);
+
+void handlemap_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    VulkanHandleMapping* handlemap, VkOpticalFlowSessionCreatePrivateDataInfoNV* toMap);
+
+void handlemap_VkOpticalFlowExecuteInfoNV(VulkanHandleMapping* handlemap,
+                                          VkOpticalFlowExecuteInfoNV* toMap);
+
+#endif
+#ifdef VK_EXT_legacy_dithering
+void handlemap_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceLegacyDitheringFeaturesEXT* toMap);
+
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+void handlemap_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* toMap);
+
+#endif
+#ifdef VK_EXT_shader_object
+void handlemap_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderObjectFeaturesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderObjectPropertiesEXT* toMap);
+
+void handlemap_VkShaderCreateInfoEXT(VulkanHandleMapping* handlemap, VkShaderCreateInfoEXT* toMap);
+
+DEFINE_ALIAS_FUNCTION(handlemap_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      handlemap_VkShaderRequiredSubgroupSizeCreateInfoEXT)
+
+#endif
+#ifdef VK_QCOM_tile_properties
+void handlemap_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceTilePropertiesFeaturesQCOM* toMap);
+
+void handlemap_VkTilePropertiesQCOM(VulkanHandleMapping* handlemap, VkTilePropertiesQCOM* toMap);
+
+#endif
+#ifdef VK_SEC_amigo_profiling
+void handlemap_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceAmigoProfilingFeaturesSEC* toMap);
+
+void handlemap_VkAmigoProfilingSubmitInfoSEC(VulkanHandleMapping* handlemap,
+                                             VkAmigoProfilingSubmitInfoSEC* toMap);
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+void handlemap_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* toMap);
+
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+void handlemap_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* toMap);
+
+void handlemap_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* toMap);
+
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+void handlemap_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* toMap);
+
+void handlemap_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* toMap);
+
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+void handlemap_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* toMap);
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+void handlemap_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* toMap);
+
+void handlemap_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    VulkanHandleMapping* handlemap, VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* toMap);
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+void handlemap_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    VulkanHandleMapping* handlemap,
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* toMap);
+
+#endif
+#ifdef VK_KHR_acceleration_structure
 void handlemap_VkAccelerationStructureBuildRangeInfoKHR(
     VulkanHandleMapping* handlemap, VkAccelerationStructureBuildRangeInfoKHR* toMap);
 
@@ -3002,6 +3793,17 @@ void handlemap_VkPhysicalDeviceRayQueryFeaturesKHR(VulkanHandleMapping* handlema
                                                    VkPhysicalDeviceRayQueryFeaturesKHR* toMap);
 
 #endif
+#ifdef VK_EXT_mesh_shader
+void handlemap_VkPhysicalDeviceMeshShaderFeaturesEXT(VulkanHandleMapping* handlemap,
+                                                     VkPhysicalDeviceMeshShaderFeaturesEXT* toMap);
+
+void handlemap_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    VulkanHandleMapping* handlemap, VkPhysicalDeviceMeshShaderPropertiesEXT* toMap);
+
+void handlemap_VkDrawMeshTasksIndirectCommandEXT(VulkanHandleMapping* handlemap,
+                                                 VkDrawMeshTasksIndirectCommandEXT* toMap);
+
+#endif
 
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_marshaling.cpp b/stream-servers/vulkan/cereal/common/goldfish_vk_marshaling.cpp
index e2d9ba0a..86804be9 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_marshaling.cpp
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_marshaling.cpp
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_marshaling
 //
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (impl) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -10521,6 +10521,2907 @@ void unmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
 }
 
 #endif
+#ifdef VK_VERSION_1_3
+void marshal_VkPhysicalDeviceVulkan13Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceVulkan13Features* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->robustImageAccess, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->inlineUniformBlock, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->pipelineCreationCacheControl, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->privateData, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderDemoteToHelperInvocation, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderTerminateInvocation, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->subgroupSizeControl, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->computeFullSubgroups, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->synchronization2, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderZeroInitializeWorkgroupMemory,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->dynamicRendering, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderIntegerDotProduct, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->maintenance4, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceVulkan13Features(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkPhysicalDeviceVulkan13Features* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->robustImageAccess, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->inlineUniformBlock, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->pipelineCreationCacheControl, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->privateData, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderDemoteToHelperInvocation, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderTerminateInvocation, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->subgroupSizeControl, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->computeFullSubgroups, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->synchronization2, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderZeroInitializeWorkgroupMemory,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->dynamicRendering, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderIntegerDotProduct, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->maintenance4, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceVulkan13Properties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceVulkan13Properties* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->minSubgroupSize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxSubgroupSize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxComputeWorkgroupSubgroups, sizeof(uint32_t));
+    vkStream->write((VkShaderStageFlags*)&forMarshaling->requiredSubgroupSizeStages,
+                    sizeof(VkShaderStageFlags));
+    vkStream->write((uint32_t*)&forMarshaling->maxInlineUniformBlockSize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorInlineUniformBlocks,
+                    sizeof(uint32_t));
+    vkStream->write(
+        (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
+        sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetInlineUniformBlocks,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxInlineUniformTotalSize, sizeof(uint32_t));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitUnsignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitSignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedSignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
+        sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitUnsignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitSignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitUnsignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitSignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitUnsignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitSignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling
+                        ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling
+                        ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling
+                        ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling
+            ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
+        sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling
+                        ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling
+                        ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling
+                        ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkDeviceSize*)&forMarshaling->storageTexelBufferOffsetAlignmentBytes,
+                    sizeof(VkDeviceSize));
+    vkStream->write((VkBool32*)&forMarshaling->storageTexelBufferOffsetSingleTexelAlignment,
+                    sizeof(VkBool32));
+    vkStream->write((VkDeviceSize*)&forMarshaling->uniformTexelBufferOffsetAlignmentBytes,
+                    sizeof(VkDeviceSize));
+    vkStream->write((VkBool32*)&forMarshaling->uniformTexelBufferOffsetSingleTexelAlignment,
+                    sizeof(VkBool32));
+    vkStream->write((VkDeviceSize*)&forMarshaling->maxBufferSize, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkPhysicalDeviceVulkan13Properties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceVulkan13Properties* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->minSubgroupSize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxSubgroupSize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxComputeWorkgroupSubgroups, sizeof(uint32_t));
+    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->requiredSubgroupSizeStages,
+                   sizeof(VkShaderStageFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxInlineUniformBlockSize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInlineUniformBlocks,
+                   sizeof(uint32_t));
+    vkStream->read(
+        (uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
+        sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetInlineUniformBlocks,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxInlineUniformTotalSize, sizeof(uint32_t));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitSignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedSignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitSignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitSignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitSignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling
+            ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->storageTexelBufferOffsetAlignmentBytes,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkBool32*)&forUnmarshaling->storageTexelBufferOffsetSingleTexelAlignment,
+                   sizeof(VkBool32));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->uniformTexelBufferOffsetAlignmentBytes,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkBool32*)&forUnmarshaling->uniformTexelBufferOffsetSingleTexelAlignment,
+                   sizeof(VkBool32));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxBufferSize, sizeof(VkDeviceSize));
+}
+
+void marshal_VkPipelineCreationFeedback(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkPipelineCreationFeedback* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkPipelineCreationFeedbackFlags*)&forMarshaling->flags,
+                    sizeof(VkPipelineCreationFeedbackFlags));
+    vkStream->write((uint64_t*)&forMarshaling->duration, sizeof(uint64_t));
+}
+
+void unmarshal_VkPipelineCreationFeedback(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkPipelineCreationFeedback* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkPipelineCreationFeedbackFlags*)&forUnmarshaling->flags,
+                   sizeof(VkPipelineCreationFeedbackFlags));
+    vkStream->read((uint64_t*)&forUnmarshaling->duration, sizeof(uint64_t));
+}
+
+void marshal_VkPipelineCreationFeedbackCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelineCreationFeedbackCreateInfo* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkPipelineCreationFeedback(
+        vkStream, rootType,
+        (VkPipelineCreationFeedback*)(forMarshaling->pPipelineCreationFeedback));
+    vkStream->write((uint32_t*)&forMarshaling->pipelineStageCreationFeedbackCount,
+                    sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->pipelineStageCreationFeedbackCount; ++i) {
+            marshal_VkPipelineCreationFeedback(
+                vkStream, rootType,
+                (VkPipelineCreationFeedback*)(forMarshaling->pPipelineStageCreationFeedbacks + i));
+        }
+    }
+}
+
+void unmarshal_VkPipelineCreationFeedbackCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineCreationFeedbackCreateInfo* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pPipelineCreationFeedback,
+                    sizeof(VkPipelineCreationFeedback));
+    unmarshal_VkPipelineCreationFeedback(
+        vkStream, rootType,
+        (VkPipelineCreationFeedback*)(forUnmarshaling->pPipelineCreationFeedback));
+    vkStream->read((uint32_t*)&forUnmarshaling->pipelineStageCreationFeedbackCount,
+                   sizeof(uint32_t));
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pPipelineStageCreationFeedbacks,
+        forUnmarshaling->pipelineStageCreationFeedbackCount * sizeof(VkPipelineCreationFeedback));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pipelineStageCreationFeedbackCount;
+             ++i) {
+            unmarshal_VkPipelineCreationFeedback(
+                vkStream, rootType,
+                (VkPipelineCreationFeedback*)(forUnmarshaling->pPipelineStageCreationFeedbacks +
+                                              i));
+        }
+    }
+}
+
+void marshal_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderTerminateInvocationFeatures* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->shaderTerminateInvocation, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderTerminateInvocationFeatures* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderTerminateInvocation, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceToolProperties(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkPhysicalDeviceToolProperties* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((char*)forMarshaling->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    vkStream->write((char*)forMarshaling->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    vkStream->write((VkToolPurposeFlags*)&forMarshaling->purposes, sizeof(VkToolPurposeFlags));
+    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    vkStream->write((char*)forMarshaling->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+}
+
+void unmarshal_VkPhysicalDeviceToolProperties(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkPhysicalDeviceToolProperties* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((char*)forUnmarshaling->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    vkStream->read((char*)forUnmarshaling->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    vkStream->read((VkToolPurposeFlags*)&forUnmarshaling->purposes, sizeof(VkToolPurposeFlags));
+    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    vkStream->read((char*)forUnmarshaling->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+}
+
+void marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->shaderDemoteToHelperInvocation, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderDemoteToHelperInvocation, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDevicePrivateDataFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePrivateDataFeatures* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->privateData, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDevicePrivateDataFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePrivateDataFeatures* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->privateData, sizeof(VkBool32));
+}
+
+void marshal_VkDevicePrivateDataCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkDevicePrivateDataCreateInfo* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->privateDataSlotRequestCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkDevicePrivateDataCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkDevicePrivateDataCreateInfo* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->privateDataSlotRequestCount, sizeof(uint32_t));
+}
+
+void marshal_VkPrivateDataSlotCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkPrivateDataSlotCreateInfo* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkPrivateDataSlotCreateFlags*)&forMarshaling->flags,
+                    sizeof(VkPrivateDataSlotCreateFlags));
+}
+
+void unmarshal_VkPrivateDataSlotCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkPrivateDataSlotCreateInfo* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPrivateDataSlotCreateFlags*)&forUnmarshaling->flags,
+                   sizeof(VkPrivateDataSlotCreateFlags));
+}
+
+void marshal_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePipelineCreationCacheControlFeatures* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->pipelineCreationCacheControl, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineCreationCacheControlFeatures* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->pipelineCreationCacheControl, sizeof(VkBool32));
+}
+
+void marshal_VkMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                              const VkMemoryBarrier2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->srcStageMask,
+                    sizeof(VkPipelineStageFlags2));
+    vkStream->write((VkAccessFlags2*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2));
+    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->dstStageMask,
+                    sizeof(VkPipelineStageFlags2));
+    vkStream->write((VkAccessFlags2*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2));
+}
+
+void unmarshal_VkMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                VkMemoryBarrier2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->srcStageMask,
+                   sizeof(VkPipelineStageFlags2));
+    vkStream->read((VkAccessFlags2*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags2));
+    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->dstStageMask,
+                   sizeof(VkPipelineStageFlags2));
+    vkStream->read((VkAccessFlags2*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags2));
+}
+
+void marshal_VkBufferMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkBufferMemoryBarrier2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->srcStageMask,
+                    sizeof(VkPipelineStageFlags2));
+    vkStream->write((VkAccessFlags2*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2));
+    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->dstStageMask,
+                    sizeof(VkPipelineStageFlags2));
+    vkStream->write((VkAccessFlags2*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2));
+    vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkBufferMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkBufferMemoryBarrier2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->srcStageMask,
+                   sizeof(VkPipelineStageFlags2));
+    vkStream->read((VkAccessFlags2*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags2));
+    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->dstStageMask,
+                   sizeof(VkPipelineStageFlags2));
+    vkStream->read((VkAccessFlags2*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags2));
+    vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+}
+
+void marshal_VkImageMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                   const VkImageMemoryBarrier2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->srcStageMask,
+                    sizeof(VkPipelineStageFlags2));
+    vkStream->write((VkAccessFlags2*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2));
+    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->dstStageMask,
+                    sizeof(VkPipelineStageFlags2));
+    vkStream->write((VkAccessFlags2*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2));
+    vkStream->write((VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
+    vkStream->write((VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
+    vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    marshal_VkImageSubresourceRange(vkStream, rootType,
+                                    (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
+}
+
+void unmarshal_VkImageMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkImageMemoryBarrier2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->srcStageMask,
+                   sizeof(VkPipelineStageFlags2));
+    vkStream->read((VkAccessFlags2*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags2));
+    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->dstStageMask,
+                   sizeof(VkPipelineStageFlags2));
+    vkStream->read((VkAccessFlags2*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags2));
+    vkStream->read((VkImageLayout*)&forUnmarshaling->oldLayout, sizeof(VkImageLayout));
+    vkStream->read((VkImageLayout*)&forUnmarshaling->newLayout, sizeof(VkImageLayout));
+    vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+                                                      (VkImage*)&forUnmarshaling->image, 1);
+    unmarshal_VkImageSubresourceRange(
+        vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
+}
+
+void marshal_VkDependencyInfo(VulkanStream* vkStream, VkStructureType rootType,
+                              const VkDependencyInfo* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
+    vkStream->write((uint32_t*)&forMarshaling->memoryBarrierCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->memoryBarrierCount; ++i) {
+            marshal_VkMemoryBarrier2(vkStream, rootType,
+                                     (const VkMemoryBarrier2*)(forMarshaling->pMemoryBarriers + i));
+        }
+    }
+    vkStream->write((uint32_t*)&forMarshaling->bufferMemoryBarrierCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferMemoryBarrierCount; ++i) {
+            marshal_VkBufferMemoryBarrier2(
+                vkStream, rootType,
+                (const VkBufferMemoryBarrier2*)(forMarshaling->pBufferMemoryBarriers + i));
+        }
+    }
+    vkStream->write((uint32_t*)&forMarshaling->imageMemoryBarrierCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageMemoryBarrierCount; ++i) {
+            marshal_VkImageMemoryBarrier2(
+                vkStream, rootType,
+                (const VkImageMemoryBarrier2*)(forMarshaling->pImageMemoryBarriers + i));
+        }
+    }
+}
+
+void unmarshal_VkDependencyInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                VkDependencyInfo* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags,
+                   sizeof(VkDependencyFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->memoryBarrierCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pMemoryBarriers,
+                    forUnmarshaling->memoryBarrierCount * sizeof(const VkMemoryBarrier2));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->memoryBarrierCount; ++i) {
+            unmarshal_VkMemoryBarrier2(vkStream, rootType,
+                                       (VkMemoryBarrier2*)(forUnmarshaling->pMemoryBarriers + i));
+        }
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->bufferMemoryBarrierCount, sizeof(uint32_t));
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pBufferMemoryBarriers,
+        forUnmarshaling->bufferMemoryBarrierCount * sizeof(const VkBufferMemoryBarrier2));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferMemoryBarrierCount; ++i) {
+            unmarshal_VkBufferMemoryBarrier2(
+                vkStream, rootType,
+                (VkBufferMemoryBarrier2*)(forUnmarshaling->pBufferMemoryBarriers + i));
+        }
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->imageMemoryBarrierCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pImageMemoryBarriers,
+                    forUnmarshaling->imageMemoryBarrierCount * sizeof(const VkImageMemoryBarrier2));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageMemoryBarrierCount; ++i) {
+            unmarshal_VkImageMemoryBarrier2(
+                vkStream, rootType,
+                (VkImageMemoryBarrier2*)(forUnmarshaling->pImageMemoryBarriers + i));
+        }
+    }
+}
+
+void marshal_VkSemaphoreSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                   const VkSemaphoreSubmitInfo* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
+                                                          1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((uint64_t*)&forMarshaling->value, sizeof(uint64_t));
+    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->stageMask,
+                    sizeof(VkPipelineStageFlags2));
+    vkStream->write((uint32_t*)&forMarshaling->deviceIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkSemaphoreSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkSemaphoreSubmitInfo* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+        &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+    vkStream->read((uint64_t*)&forUnmarshaling->value, sizeof(uint64_t));
+    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->stageMask,
+                   sizeof(VkPipelineStageFlags2));
+    vkStream->read((uint32_t*)&forUnmarshaling->deviceIndex, sizeof(uint32_t));
+}
+
+void marshal_VkCommandBufferSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                       const VkCommandBufferSubmitInfo* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&forMarshaling->commandBuffer,
+                                                              &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void unmarshal_VkCommandBufferSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkCommandBufferSubmitInfo* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(
+        &cgen_var_0, (VkCommandBuffer*)&forUnmarshaling->commandBuffer, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
+}
+
+void marshal_VkSubmitInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                           const VkSubmitInfo2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkSubmitFlags*)&forMarshaling->flags, sizeof(VkSubmitFlags));
+    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreInfoCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->waitSemaphoreInfoCount; ++i) {
+            marshal_VkSemaphoreSubmitInfo(
+                vkStream, rootType,
+                (const VkSemaphoreSubmitInfo*)(forMarshaling->pWaitSemaphoreInfos + i));
+        }
+    }
+    vkStream->write((uint32_t*)&forMarshaling->commandBufferInfoCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->commandBufferInfoCount; ++i) {
+            marshal_VkCommandBufferSubmitInfo(
+                vkStream, rootType,
+                (const VkCommandBufferSubmitInfo*)(forMarshaling->pCommandBufferInfos + i));
+        }
+    }
+    vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreInfoCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->signalSemaphoreInfoCount; ++i) {
+            marshal_VkSemaphoreSubmitInfo(
+                vkStream, rootType,
+                (const VkSemaphoreSubmitInfo*)(forMarshaling->pSignalSemaphoreInfos + i));
+        }
+    }
+}
+
+void unmarshal_VkSubmitInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                             VkSubmitInfo2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkSubmitFlags*)&forUnmarshaling->flags, sizeof(VkSubmitFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreInfoCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphoreInfos,
+                    forUnmarshaling->waitSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfo));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->waitSemaphoreInfoCount; ++i) {
+            unmarshal_VkSemaphoreSubmitInfo(
+                vkStream, rootType,
+                (VkSemaphoreSubmitInfo*)(forUnmarshaling->pWaitSemaphoreInfos + i));
+        }
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->commandBufferInfoCount, sizeof(uint32_t));
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pCommandBufferInfos,
+        forUnmarshaling->commandBufferInfoCount * sizeof(const VkCommandBufferSubmitInfo));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->commandBufferInfoCount; ++i) {
+            unmarshal_VkCommandBufferSubmitInfo(
+                vkStream, rootType,
+                (VkCommandBufferSubmitInfo*)(forUnmarshaling->pCommandBufferInfos + i));
+        }
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreInfoCount, sizeof(uint32_t));
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pSignalSemaphoreInfos,
+        forUnmarshaling->signalSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfo));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->signalSemaphoreInfoCount; ++i) {
+            unmarshal_VkSemaphoreSubmitInfo(
+                vkStream, rootType,
+                (VkSemaphoreSubmitInfo*)(forUnmarshaling->pSignalSemaphoreInfos + i));
+        }
+    }
+}
+
+void marshal_VkPhysicalDeviceSynchronization2Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceSynchronization2Features* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->synchronization2, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSynchronization2Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSynchronization2Features* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->synchronization2, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->shaderZeroInitializeWorkgroupMemory,
+                    sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderZeroInitializeWorkgroupMemory,
+                   sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceImageRobustnessFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceImageRobustnessFeatures* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->robustImageAccess, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceImageRobustnessFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageRobustnessFeatures* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->robustImageAccess, sizeof(VkBool32));
+}
+
+void marshal_VkBufferCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                           const VkBufferCopy2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDeviceSize*)&forMarshaling->srcOffset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->dstOffset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkBufferCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                             VkBufferCopy2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->srcOffset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->dstOffset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+}
+
+void marshal_VkCopyBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                               const VkCopyBufferInfo2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->srcBuffer, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    uint64_t cgen_var_1;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->dstBuffer, &cgen_var_1, 1);
+    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+            marshal_VkBufferCopy2(vkStream, rootType,
+                                  (const VkBufferCopy2*)(forMarshaling->pRegions + i));
+        }
+    }
+}
+
+void unmarshal_VkCopyBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                 VkCopyBufferInfo2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+                                                       (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
+    uint64_t cgen_var_1;
+    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
+                                                       (VkBuffer*)&forUnmarshaling->dstBuffer, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkBufferCopy2));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+            unmarshal_VkBufferCopy2(vkStream, rootType,
+                                    (VkBufferCopy2*)(forUnmarshaling->pRegions + i));
+        }
+    }
+}
+
+void marshal_VkImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                          const VkImageCopy2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkImageSubresourceLayers(vkStream, rootType,
+                                     (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
+    marshal_VkImageSubresourceLayers(vkStream, rootType,
+                                     (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset));
+    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
+}
+
+void unmarshal_VkImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                            VkImageCopy2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
+    unmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset));
+    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
+}
+
+void marshal_VkCopyImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                              const VkCopyImageInfo2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_1;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
+    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
+    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+            marshal_VkImageCopy2(vkStream, rootType,
+                                 (const VkImageCopy2*)(forMarshaling->pRegions + i));
+        }
+    }
+}
+
+void unmarshal_VkCopyImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                VkCopyImageInfo2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_1;
+    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
+                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
+    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkImageCopy2));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+            unmarshal_VkImageCopy2(vkStream, rootType,
+                                   (VkImageCopy2*)(forUnmarshaling->pRegions + i));
+        }
+    }
+}
+
+void marshal_VkBufferImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                                const VkBufferImageCopy2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDeviceSize*)&forMarshaling->bufferOffset, sizeof(VkDeviceSize));
+    vkStream->write((uint32_t*)&forMarshaling->bufferRowLength, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
+    marshal_VkImageSubresourceLayers(vkStream, rootType,
+                                     (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
+    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
+    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
+}
+
+void unmarshal_VkBufferImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                                  VkBufferImageCopy2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->bufferOffset, sizeof(VkDeviceSize));
+    vkStream->read((uint32_t*)&forUnmarshaling->bufferRowLength, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->bufferImageHeight, sizeof(uint32_t));
+    unmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
+    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
+    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
+}
+
+void marshal_VkCopyBufferToImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                      const VkCopyBufferToImageInfo2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->srcBuffer, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    uint64_t cgen_var_1;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
+    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
+    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+            marshal_VkBufferImageCopy2(vkStream, rootType,
+                                       (const VkBufferImageCopy2*)(forMarshaling->pRegions + i));
+        }
+    }
+}
+
+void unmarshal_VkCopyBufferToImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkCopyBufferToImageInfo2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+                                                       (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
+    uint64_t cgen_var_1;
+    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
+                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
+    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkBufferImageCopy2));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+            unmarshal_VkBufferImageCopy2(vkStream, rootType,
+                                         (VkBufferImageCopy2*)(forUnmarshaling->pRegions + i));
+        }
+    }
+}
+
+void marshal_VkCopyImageToBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                      const VkCopyImageToBufferInfo2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_1;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->dstBuffer, &cgen_var_1, 1);
+    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+            marshal_VkBufferImageCopy2(vkStream, rootType,
+                                       (const VkBufferImageCopy2*)(forMarshaling->pRegions + i));
+        }
+    }
+}
+
+void unmarshal_VkCopyImageToBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkCopyImageToBufferInfo2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_1;
+    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
+                                                       (VkBuffer*)&forUnmarshaling->dstBuffer, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkBufferImageCopy2));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+            unmarshal_VkBufferImageCopy2(vkStream, rootType,
+                                         (VkBufferImageCopy2*)(forUnmarshaling->pRegions + i));
+        }
+    }
+}
+
+void marshal_VkImageBlit2(VulkanStream* vkStream, VkStructureType rootType,
+                          const VkImageBlit2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkImageSubresourceLayers(vkStream, rootType,
+                                     (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i));
+    }
+    marshal_VkImageSubresourceLayers(vkStream, rootType,
+                                     (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i));
+    }
+}
+
+void unmarshal_VkImageBlit2(VulkanStream* vkStream, VkStructureType rootType,
+                            VkImageBlit2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->srcOffsets + i));
+    }
+    unmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->dstOffsets + i));
+    }
+}
+
+void marshal_VkBlitImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                              const VkBlitImageInfo2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_1;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
+    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
+    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+            marshal_VkImageBlit2(vkStream, rootType,
+                                 (const VkImageBlit2*)(forMarshaling->pRegions + i));
+        }
+    }
+    vkStream->write((VkFilter*)&forMarshaling->filter, sizeof(VkFilter));
+}
+
+void unmarshal_VkBlitImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                VkBlitImageInfo2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_1;
+    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
+                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
+    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkImageBlit2));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+            unmarshal_VkImageBlit2(vkStream, rootType,
+                                   (VkImageBlit2*)(forUnmarshaling->pRegions + i));
+        }
+    }
+    vkStream->read((VkFilter*)&forUnmarshaling->filter, sizeof(VkFilter));
+}
+
+void marshal_VkImageResolve2(VulkanStream* vkStream, VkStructureType rootType,
+                             const VkImageResolve2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkImageSubresourceLayers(vkStream, rootType,
+                                     (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
+    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
+    marshal_VkImageSubresourceLayers(vkStream, rootType,
+                                     (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
+    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset));
+    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
+}
+
+void unmarshal_VkImageResolve2(VulkanStream* vkStream, VkStructureType rootType,
+                               VkImageResolve2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
+    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
+    unmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
+    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset));
+    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
+}
+
+void marshal_VkResolveImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                 const VkResolveImageInfo2* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_1;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
+    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
+    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+            marshal_VkImageResolve2(vkStream, rootType,
+                                    (const VkImageResolve2*)(forMarshaling->pRegions + i));
+        }
+    }
+}
+
+void unmarshal_VkResolveImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                   VkResolveImageInfo2* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
+    uint64_t cgen_var_1;
+    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
+                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
+    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkImageResolve2));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+            unmarshal_VkImageResolve2(vkStream, rootType,
+                                      (VkImageResolve2*)(forUnmarshaling->pRegions + i));
+        }
+    }
+}
+
+void marshal_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceSubgroupSizeControlFeatures* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->subgroupSizeControl, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->computeFullSubgroups, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSubgroupSizeControlFeatures* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->subgroupSizeControl, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->computeFullSubgroups, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceSubgroupSizeControlProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceSubgroupSizeControlProperties* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->minSubgroupSize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxSubgroupSize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxComputeWorkgroupSubgroups, sizeof(uint32_t));
+    vkStream->write((VkShaderStageFlags*)&forMarshaling->requiredSubgroupSizeStages,
+                    sizeof(VkShaderStageFlags));
+}
+
+void unmarshal_VkPhysicalDeviceSubgroupSizeControlProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSubgroupSizeControlProperties* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->minSubgroupSize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxSubgroupSize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxComputeWorkgroupSubgroups, sizeof(uint32_t));
+    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->requiredSubgroupSizeStages,
+                   sizeof(VkShaderStageFlags));
+}
+
+void marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->requiredSubgroupSize, sizeof(uint32_t));
+}
+
+void unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->requiredSubgroupSize, sizeof(uint32_t));
+}
+
+void marshal_VkPhysicalDeviceInlineUniformBlockFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceInlineUniformBlockFeatures* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->inlineUniformBlock, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind,
+                    sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceInlineUniformBlockFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceInlineUniformBlockFeatures* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->inlineUniformBlock, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind,
+                   sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceInlineUniformBlockProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceInlineUniformBlockProperties* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->maxInlineUniformBlockSize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorInlineUniformBlocks,
+                    sizeof(uint32_t));
+    vkStream->write(
+        (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
+        sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetInlineUniformBlocks,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks,
+                    sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceInlineUniformBlockProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceInlineUniformBlockProperties* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxInlineUniformBlockSize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInlineUniformBlocks,
+                   sizeof(uint32_t));
+    vkStream->read(
+        (uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
+        sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetInlineUniformBlocks,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks,
+                   sizeof(uint32_t));
+}
+
+void marshal_VkWriteDescriptorSetInlineUniformBlock(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkWriteDescriptorSetInlineUniformBlock* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->dataSize, sizeof(uint32_t));
+    vkStream->write((const void*)forMarshaling->pData,
+                    forMarshaling->dataSize * sizeof(const uint8_t));
+}
+
+void unmarshal_VkWriteDescriptorSetInlineUniformBlock(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkWriteDescriptorSetInlineUniformBlock* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->dataSize, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pData,
+                    forUnmarshaling->dataSize * sizeof(const uint8_t));
+    vkStream->read((void*)forUnmarshaling->pData,
+                   forUnmarshaling->dataSize * sizeof(const uint8_t));
+}
+
+void marshal_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDescriptorPoolInlineUniformBlockCreateInfo* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->maxInlineUniformBlockBindings, sizeof(uint32_t));
+}
+
+void unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorPoolInlineUniformBlockCreateInfo* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxInlineUniformBlockBindings, sizeof(uint32_t));
+}
+
+void marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
+}
+
+void marshal_VkRenderingAttachmentInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                       const VkRenderingAttachmentInfo* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
+                                                          1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
+    vkStream->write((VkResolveModeFlagBits*)&forMarshaling->resolveMode,
+                    sizeof(VkResolveModeFlagBits));
+    uint64_t cgen_var_1;
+    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->resolveImageView,
+                                                          &cgen_var_1, 1);
+    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->write((VkImageLayout*)&forMarshaling->resolveImageLayout, sizeof(VkImageLayout));
+    vkStream->write((VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
+    vkStream->write((VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
+    marshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forMarshaling->clearValue));
+}
+
+void unmarshal_VkRenderingAttachmentInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkRenderingAttachmentInfo* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImageView(
+        &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
+    vkStream->read((VkResolveModeFlagBits*)&forUnmarshaling->resolveMode,
+                   sizeof(VkResolveModeFlagBits));
+    uint64_t cgen_var_1;
+    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImageView(
+        &cgen_var_1, (VkImageView*)&forUnmarshaling->resolveImageView, 1);
+    vkStream->read((VkImageLayout*)&forUnmarshaling->resolveImageLayout, sizeof(VkImageLayout));
+    vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, sizeof(VkAttachmentLoadOp));
+    vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, sizeof(VkAttachmentStoreOp));
+    unmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forUnmarshaling->clearValue));
+}
+
+void marshal_VkRenderingInfo(VulkanStream* vkStream, VkStructureType rootType,
+                             const VkRenderingInfo* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkRenderingFlags*)&forMarshaling->flags, sizeof(VkRenderingFlags));
+    marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->renderArea));
+    vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
+            marshal_VkRenderingAttachmentInfo(
+                vkStream, rootType,
+                (const VkRenderingAttachmentInfo*)(forMarshaling->pColorAttachments + i));
+        }
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDepthAttachment;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pDepthAttachment) {
+        marshal_VkRenderingAttachmentInfo(
+            vkStream, rootType,
+            (const VkRenderingAttachmentInfo*)(forMarshaling->pDepthAttachment));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pStencilAttachment;
+    vkStream->putBe64(cgen_var_1);
+    if (forMarshaling->pStencilAttachment) {
+        marshal_VkRenderingAttachmentInfo(
+            vkStream, rootType,
+            (const VkRenderingAttachmentInfo*)(forMarshaling->pStencilAttachment));
+    }
+}
+
+void unmarshal_VkRenderingInfo(VulkanStream* vkStream, VkStructureType rootType,
+                               VkRenderingInfo* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkRenderingFlags*)&forUnmarshaling->flags, sizeof(VkRenderingFlags));
+    unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->renderArea));
+    vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pColorAttachments,
+        forUnmarshaling->colorAttachmentCount * sizeof(const VkRenderingAttachmentInfo));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
+            unmarshal_VkRenderingAttachmentInfo(
+                vkStream, rootType,
+                (VkRenderingAttachmentInfo*)(forUnmarshaling->pColorAttachments + i));
+        }
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pDepthAttachment =
+        (const VkRenderingAttachmentInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pDepthAttachment) {
+        vkStream->alloc((void**)&forUnmarshaling->pDepthAttachment,
+                        sizeof(const VkRenderingAttachmentInfo));
+        unmarshal_VkRenderingAttachmentInfo(
+            vkStream, rootType, (VkRenderingAttachmentInfo*)(forUnmarshaling->pDepthAttachment));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pStencilAttachment =
+        (const VkRenderingAttachmentInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pStencilAttachment) {
+        vkStream->alloc((void**)&forUnmarshaling->pStencilAttachment,
+                        sizeof(const VkRenderingAttachmentInfo));
+        unmarshal_VkRenderingAttachmentInfo(
+            vkStream, rootType, (VkRenderingAttachmentInfo*)(forUnmarshaling->pStencilAttachment));
+    }
+}
+
+void marshal_VkPipelineRenderingCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkPipelineRenderingCreateInfo* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pColorAttachmentFormats;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pColorAttachmentFormats) {
+        vkStream->write((const VkFormat*)forMarshaling->pColorAttachmentFormats,
+                        forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
+    }
+    vkStream->write((VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
+    vkStream->write((VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
+}
+
+void unmarshal_VkPipelineRenderingCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkPipelineRenderingCreateInfo* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pColorAttachmentFormats = (const VkFormat*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pColorAttachmentFormats) {
+        vkStream->alloc((void**)&forUnmarshaling->pColorAttachmentFormats,
+                        forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+        vkStream->read((VkFormat*)forUnmarshaling->pColorAttachmentFormats,
+                       forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+    }
+    vkStream->read((VkFormat*)&forUnmarshaling->depthAttachmentFormat, sizeof(VkFormat));
+    vkStream->read((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, sizeof(VkFormat));
+}
+
+void marshal_VkPhysicalDeviceDynamicRenderingFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDynamicRenderingFeatures* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->dynamicRendering, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceDynamicRenderingFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDynamicRenderingFeatures* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->dynamicRendering, sizeof(VkBool32));
+}
+
+void marshal_VkCommandBufferInheritanceRenderingInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkCommandBufferInheritanceRenderingInfo* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkRenderingFlags*)&forMarshaling->flags, sizeof(VkRenderingFlags));
+    vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
+    vkStream->write((const VkFormat*)forMarshaling->pColorAttachmentFormats,
+                    forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
+    vkStream->write((VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
+    vkStream->write((VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
+    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
+                    sizeof(VkSampleCountFlagBits));
+}
+
+void unmarshal_VkCommandBufferInheritanceRenderingInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkCommandBufferInheritanceRenderingInfo* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkRenderingFlags*)&forUnmarshaling->flags, sizeof(VkRenderingFlags));
+    vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pColorAttachmentFormats,
+                    forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+    vkStream->read((VkFormat*)forUnmarshaling->pColorAttachmentFormats,
+                   forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+    vkStream->read((VkFormat*)&forUnmarshaling->depthAttachmentFormat, sizeof(VkFormat));
+    vkStream->read((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, sizeof(VkFormat));
+    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples,
+                   sizeof(VkSampleCountFlagBits));
+}
+
+void marshal_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderIntegerDotProductFeatures* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->shaderIntegerDotProduct, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderIntegerDotProductFeatures* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderIntegerDotProduct, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderIntegerDotProductProperties* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitUnsignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitSignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedSignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
+        sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitUnsignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitSignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitUnsignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitSignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitUnsignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitSignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling
+                        ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling
+                        ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling
+                        ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling
+            ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
+        sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling
+                        ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling
+                        ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling
+                        ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
+                    sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderIntegerDotProductProperties* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitSignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedSignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitSignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitSignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitSignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling
+            ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling
+                       ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
+                   sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceTexelBufferAlignmentProperties* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDeviceSize*)&forMarshaling->storageTexelBufferOffsetAlignmentBytes,
+                    sizeof(VkDeviceSize));
+    vkStream->write((VkBool32*)&forMarshaling->storageTexelBufferOffsetSingleTexelAlignment,
+                    sizeof(VkBool32));
+    vkStream->write((VkDeviceSize*)&forMarshaling->uniformTexelBufferOffsetAlignmentBytes,
+                    sizeof(VkDeviceSize));
+    vkStream->write((VkBool32*)&forMarshaling->uniformTexelBufferOffsetSingleTexelAlignment,
+                    sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceTexelBufferAlignmentProperties* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->storageTexelBufferOffsetAlignmentBytes,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkBool32*)&forUnmarshaling->storageTexelBufferOffsetSingleTexelAlignment,
+                   sizeof(VkBool32));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->uniformTexelBufferOffsetAlignmentBytes,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkBool32*)&forUnmarshaling->uniformTexelBufferOffsetSingleTexelAlignment,
+                   sizeof(VkBool32));
+}
+
+void marshal_VkFormatProperties3(VulkanStream* vkStream, VkStructureType rootType,
+                                 const VkFormatProperties3* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkFormatFeatureFlags2*)&forMarshaling->linearTilingFeatures,
+                    sizeof(VkFormatFeatureFlags2));
+    vkStream->write((VkFormatFeatureFlags2*)&forMarshaling->optimalTilingFeatures,
+                    sizeof(VkFormatFeatureFlags2));
+    vkStream->write((VkFormatFeatureFlags2*)&forMarshaling->bufferFeatures,
+                    sizeof(VkFormatFeatureFlags2));
+}
+
+void unmarshal_VkFormatProperties3(VulkanStream* vkStream, VkStructureType rootType,
+                                   VkFormatProperties3* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkFormatFeatureFlags2*)&forUnmarshaling->linearTilingFeatures,
+                   sizeof(VkFormatFeatureFlags2));
+    vkStream->read((VkFormatFeatureFlags2*)&forUnmarshaling->optimalTilingFeatures,
+                   sizeof(VkFormatFeatureFlags2));
+    vkStream->read((VkFormatFeatureFlags2*)&forUnmarshaling->bufferFeatures,
+                   sizeof(VkFormatFeatureFlags2));
+}
+
+void marshal_VkPhysicalDeviceMaintenance4Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMaintenance4Features* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->maintenance4, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMaintenance4Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance4Features* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->maintenance4, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceMaintenance4Properties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMaintenance4Properties* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDeviceSize*)&forMarshaling->maxBufferSize, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkPhysicalDeviceMaintenance4Properties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance4Properties* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxBufferSize, sizeof(VkDeviceSize));
+}
+
+void marshal_VkDeviceBufferMemoryRequirements(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDeviceBufferMemoryRequirements* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkBufferCreateInfo(vkStream, rootType,
+                               (const VkBufferCreateInfo*)(forMarshaling->pCreateInfo));
+}
+
+void unmarshal_VkDeviceBufferMemoryRequirements(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkDeviceBufferMemoryRequirements* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pCreateInfo, sizeof(const VkBufferCreateInfo));
+    unmarshal_VkBufferCreateInfo(vkStream, rootType,
+                                 (VkBufferCreateInfo*)(forUnmarshaling->pCreateInfo));
+}
+
+void marshal_VkDeviceImageMemoryRequirements(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkDeviceImageMemoryRequirements* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkImageCreateInfo(vkStream, rootType,
+                              (const VkImageCreateInfo*)(forMarshaling->pCreateInfo));
+    vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect,
+                    sizeof(VkImageAspectFlagBits));
+}
+
+void unmarshal_VkDeviceImageMemoryRequirements(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkDeviceImageMemoryRequirements* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pCreateInfo, sizeof(const VkImageCreateInfo));
+    unmarshal_VkImageCreateInfo(vkStream, rootType,
+                                (VkImageCreateInfo*)(forUnmarshaling->pCreateInfo));
+    vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect,
+                   sizeof(VkImageAspectFlagBits));
+}
+
+#endif
 #ifdef VK_KHR_surface
 void marshal_VkSurfaceCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkSurfaceCapabilitiesKHR* forMarshaling) {
@@ -11515,9 +14416,44 @@ void unmarshal_VkWin32SurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureTy
 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
 #endif
 #ifdef VK_KHR_video_queue
-void marshal_VkVideoQueueFamilyProperties2KHR(
+void marshal_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkQueueFamilyQueryResultStatusPropertiesKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->queryResultStatusSupport, sizeof(VkBool32));
+}
+
+void unmarshal_VkQueueFamilyQueryResultStatusPropertiesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoQueueFamilyProperties2KHR* forMarshaling) {
+    VkQueueFamilyQueryResultStatusPropertiesKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->queryResultStatusSupport, sizeof(VkBool32));
+}
+
+void marshal_VkQueueFamilyVideoPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkQueueFamilyVideoPropertiesKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11528,8 +14464,8 @@ void marshal_VkVideoQueueFamilyProperties2KHR(
                     sizeof(VkVideoCodecOperationFlagsKHR));
 }
 
-void unmarshal_VkVideoQueueFamilyProperties2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkVideoQueueFamilyProperties2KHR* forUnmarshaling) {
+void unmarshal_VkQueueFamilyVideoPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkQueueFamilyVideoPropertiesKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11552,8 +14488,8 @@ void unmarshal_VkVideoQueueFamilyProperties2KHR(VulkanStream* vkStream, VkStruct
                    sizeof(VkVideoCodecOperationFlagsKHR));
 }
 
-void marshal_VkVideoProfileKHR(VulkanStream* vkStream, VkStructureType rootType,
-                               const VkVideoProfileKHR* forMarshaling) {
+void marshal_VkVideoProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                   const VkVideoProfileInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11570,8 +14506,8 @@ void marshal_VkVideoProfileKHR(VulkanStream* vkStream, VkStructureType rootType,
                     sizeof(VkVideoComponentBitDepthFlagsKHR));
 }
 
-void unmarshal_VkVideoProfileKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                 VkVideoProfileKHR* forUnmarshaling) {
+void unmarshal_VkVideoProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkVideoProfileInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11600,8 +14536,8 @@ void unmarshal_VkVideoProfileKHR(VulkanStream* vkStream, VkStructureType rootTyp
                    sizeof(VkVideoComponentBitDepthFlagsKHR));
 }
 
-void marshal_VkVideoProfilesKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                const VkVideoProfilesKHR* forMarshaling) {
+void marshal_VkVideoProfileListInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                       const VkVideoProfileListInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11609,12 +14545,16 @@ void marshal_VkVideoProfilesKHR(VulkanStream* vkStream, VkStructureType rootType
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->profileCount, sizeof(uint32_t));
-    marshal_VkVideoProfileKHR(vkStream, rootType,
-                              (const VkVideoProfileKHR*)(forMarshaling->pProfiles));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->profileCount; ++i) {
+            marshal_VkVideoProfileInfoKHR(
+                vkStream, rootType, (const VkVideoProfileInfoKHR*)(forMarshaling->pProfiles + i));
+        }
+    }
 }
 
-void unmarshal_VkVideoProfilesKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                  VkVideoProfilesKHR* forUnmarshaling) {
+void unmarshal_VkVideoProfileListInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkVideoProfileListInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11634,9 +14574,14 @@ void unmarshal_VkVideoProfilesKHR(VulkanStream* vkStream, VkStructureType rootTy
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
     vkStream->read((uint32_t*)&forUnmarshaling->profileCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pProfiles, sizeof(const VkVideoProfileKHR));
-    unmarshal_VkVideoProfileKHR(vkStream, rootType,
-                                (VkVideoProfileKHR*)(forUnmarshaling->pProfiles));
+    vkStream->alloc((void**)&forUnmarshaling->pProfiles,
+                    forUnmarshaling->profileCount * sizeof(const VkVideoProfileInfoKHR));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->profileCount; ++i) {
+            unmarshal_VkVideoProfileInfoKHR(
+                vkStream, rootType, (VkVideoProfileInfoKHR*)(forUnmarshaling->pProfiles + i));
+        }
+    }
 }
 
 void marshal_VkVideoCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
@@ -11647,18 +14592,19 @@ void marshal_VkVideoCapabilitiesKHR(VulkanStream* vkStream, VkStructureType root
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkVideoCapabilityFlagsKHR*)&forMarshaling->capabilityFlags,
+    vkStream->write((VkVideoCapabilityFlagsKHR*)&forMarshaling->flags,
                     sizeof(VkVideoCapabilityFlagsKHR));
     vkStream->write((VkDeviceSize*)&forMarshaling->minBitstreamBufferOffsetAlignment,
                     sizeof(VkDeviceSize));
     vkStream->write((VkDeviceSize*)&forMarshaling->minBitstreamBufferSizeAlignment,
                     sizeof(VkDeviceSize));
-    marshal_VkExtent2D(vkStream, rootType,
-                       (VkExtent2D*)(&forMarshaling->videoPictureExtentGranularity));
-    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minExtent));
-    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxExtent));
-    vkStream->write((uint32_t*)&forMarshaling->maxReferencePicturesSlotsCount, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->maxReferencePicturesActiveCount, sizeof(uint32_t));
+    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->pictureAccessGranularity));
+    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minCodedExtent));
+    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxCodedExtent));
+    vkStream->write((uint32_t*)&forMarshaling->maxDpbSlots, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxActiveReferencePictures, sizeof(uint32_t));
+    marshal_VkExtensionProperties(vkStream, rootType,
+                                  (VkExtensionProperties*)(&forMarshaling->stdHeaderVersion));
 }
 
 void unmarshal_VkVideoCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
@@ -11681,18 +14627,20 @@ void unmarshal_VkVideoCapabilitiesKHR(VulkanStream* vkStream, VkStructureType ro
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkVideoCapabilityFlagsKHR*)&forUnmarshaling->capabilityFlags,
+    vkStream->read((VkVideoCapabilityFlagsKHR*)&forUnmarshaling->flags,
                    sizeof(VkVideoCapabilityFlagsKHR));
     vkStream->read((VkDeviceSize*)&forUnmarshaling->minBitstreamBufferOffsetAlignment,
                    sizeof(VkDeviceSize));
     vkStream->read((VkDeviceSize*)&forUnmarshaling->minBitstreamBufferSizeAlignment,
                    sizeof(VkDeviceSize));
     unmarshal_VkExtent2D(vkStream, rootType,
-                         (VkExtent2D*)(&forUnmarshaling->videoPictureExtentGranularity));
-    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minExtent));
-    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxExtent));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxReferencePicturesSlotsCount, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxReferencePicturesActiveCount, sizeof(uint32_t));
+                         (VkExtent2D*)(&forUnmarshaling->pictureAccessGranularity));
+    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minCodedExtent));
+    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxCodedExtent));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDpbSlots, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxActiveReferencePictures, sizeof(uint32_t));
+    unmarshal_VkExtensionProperties(vkStream, rootType,
+                                    (VkExtensionProperties*)(&forUnmarshaling->stdHeaderVersion));
 }
 
 void marshal_VkPhysicalDeviceVideoFormatInfoKHR(
@@ -11705,8 +14653,6 @@ void marshal_VkPhysicalDeviceVideoFormatInfoKHR(
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
     vkStream->write((VkImageUsageFlags*)&forMarshaling->imageUsage, sizeof(VkImageUsageFlags));
-    marshal_VkVideoProfilesKHR(vkStream, rootType,
-                               (const VkVideoProfilesKHR*)(forMarshaling->pVideoProfiles));
 }
 
 void unmarshal_VkPhysicalDeviceVideoFormatInfoKHR(
@@ -11731,9 +14677,6 @@ void unmarshal_VkPhysicalDeviceVideoFormatInfoKHR(
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
     vkStream->read((VkImageUsageFlags*)&forUnmarshaling->imageUsage, sizeof(VkImageUsageFlags));
-    vkStream->alloc((void**)&forUnmarshaling->pVideoProfiles, sizeof(const VkVideoProfilesKHR));
-    unmarshal_VkVideoProfilesKHR(vkStream, rootType,
-                                 (VkVideoProfilesKHR*)(forUnmarshaling->pVideoProfiles));
 }
 
 void marshal_VkVideoFormatPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
@@ -11745,6 +14688,13 @@ void marshal_VkVideoFormatPropertiesKHR(VulkanStream* vkStream, VkStructureType
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
     vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+    marshal_VkComponentMapping(vkStream, rootType,
+                               (VkComponentMapping*)(&forMarshaling->componentMapping));
+    vkStream->write((VkImageCreateFlags*)&forMarshaling->imageCreateFlags,
+                    sizeof(VkImageCreateFlags));
+    vkStream->write((VkImageType*)&forMarshaling->imageType, sizeof(VkImageType));
+    vkStream->write((VkImageTiling*)&forMarshaling->imageTiling, sizeof(VkImageTiling));
+    vkStream->write((VkImageUsageFlags*)&forMarshaling->imageUsageFlags, sizeof(VkImageUsageFlags));
 }
 
 void unmarshal_VkVideoFormatPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
@@ -11768,10 +14718,18 @@ void unmarshal_VkVideoFormatPropertiesKHR(VulkanStream* vkStream, VkStructureTyp
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
     vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+    unmarshal_VkComponentMapping(vkStream, rootType,
+                                 (VkComponentMapping*)(&forUnmarshaling->componentMapping));
+    vkStream->read((VkImageCreateFlags*)&forUnmarshaling->imageCreateFlags,
+                   sizeof(VkImageCreateFlags));
+    vkStream->read((VkImageType*)&forUnmarshaling->imageType, sizeof(VkImageType));
+    vkStream->read((VkImageTiling*)&forUnmarshaling->imageTiling, sizeof(VkImageTiling));
+    vkStream->read((VkImageUsageFlags*)&forUnmarshaling->imageUsageFlags,
+                   sizeof(VkImageUsageFlags));
 }
 
-void marshal_VkVideoPictureResourceKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                       const VkVideoPictureResourceKHR* forMarshaling) {
+void marshal_VkVideoPictureResourceInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkVideoPictureResourceInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11787,8 +14745,8 @@ void marshal_VkVideoPictureResourceKHR(VulkanStream* vkStream, VkStructureType r
     vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
 }
 
-void unmarshal_VkVideoPictureResourceKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                         VkVideoPictureResourceKHR* forUnmarshaling) {
+void unmarshal_VkVideoPictureResourceInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkVideoPictureResourceInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11816,21 +14774,27 @@ void unmarshal_VkVideoPictureResourceKHR(VulkanStream* vkStream, VkStructureType
         &cgen_var_0, (VkImageView*)&forUnmarshaling->imageViewBinding, 1);
 }
 
-void marshal_VkVideoReferenceSlotKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                     const VkVideoReferenceSlotKHR* forMarshaling) {
+void marshal_VkVideoReferenceSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkVideoReferenceSlotInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((int8_t*)&forMarshaling->slotIndex, sizeof(int8_t));
-    marshal_VkVideoPictureResourceKHR(
-        vkStream, rootType, (const VkVideoPictureResourceKHR*)(forMarshaling->pPictureResource));
+    vkStream->write((int32_t*)&forMarshaling->slotIndex, sizeof(int32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pPictureResource;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pPictureResource) {
+        marshal_VkVideoPictureResourceInfoKHR(
+            vkStream, rootType,
+            (const VkVideoPictureResourceInfoKHR*)(forMarshaling->pPictureResource));
+    }
 }
 
-void unmarshal_VkVideoReferenceSlotKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                       VkVideoReferenceSlotKHR* forUnmarshaling) {
+void unmarshal_VkVideoReferenceSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkVideoReferenceSlotInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11849,15 +14813,22 @@ void unmarshal_VkVideoReferenceSlotKHR(VulkanStream* vkStream, VkStructureType r
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((int8_t*)&forUnmarshaling->slotIndex, sizeof(int8_t));
-    vkStream->alloc((void**)&forUnmarshaling->pPictureResource,
-                    sizeof(const VkVideoPictureResourceKHR));
-    unmarshal_VkVideoPictureResourceKHR(
-        vkStream, rootType, (VkVideoPictureResourceKHR*)(forUnmarshaling->pPictureResource));
+    vkStream->read((int32_t*)&forUnmarshaling->slotIndex, sizeof(int32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pPictureResource =
+        (const VkVideoPictureResourceInfoKHR*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pPictureResource) {
+        vkStream->alloc((void**)&forUnmarshaling->pPictureResource,
+                        sizeof(const VkVideoPictureResourceInfoKHR));
+        unmarshal_VkVideoPictureResourceInfoKHR(
+            vkStream, rootType,
+            (VkVideoPictureResourceInfoKHR*)(forUnmarshaling->pPictureResource));
+    }
 }
 
-void marshal_VkVideoGetMemoryPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           const VkVideoGetMemoryPropertiesKHR* forMarshaling) {
+void marshal_VkVideoSessionMemoryRequirementsKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoSessionMemoryRequirementsKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11865,12 +14836,13 @@ void marshal_VkVideoGetMemoryPropertiesKHR(VulkanStream* vkStream, VkStructureTy
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->memoryBindIndex, sizeof(uint32_t));
-    marshal_VkMemoryRequirements2(vkStream, rootType,
-                                  (VkMemoryRequirements2*)(forMarshaling->pMemoryRequirements));
+    marshal_VkMemoryRequirements(vkStream, rootType,
+                                 (VkMemoryRequirements*)(&forMarshaling->memoryRequirements));
 }
 
-void unmarshal_VkVideoGetMemoryPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                             VkVideoGetMemoryPropertiesKHR* forUnmarshaling) {
+void unmarshal_VkVideoSessionMemoryRequirementsKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoSessionMemoryRequirementsKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11890,13 +14862,12 @@ void unmarshal_VkVideoGetMemoryPropertiesKHR(VulkanStream* vkStream, VkStructure
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
     vkStream->read((uint32_t*)&forUnmarshaling->memoryBindIndex, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pMemoryRequirements, sizeof(VkMemoryRequirements2));
-    unmarshal_VkMemoryRequirements2(vkStream, rootType,
-                                    (VkMemoryRequirements2*)(forUnmarshaling->pMemoryRequirements));
+    unmarshal_VkMemoryRequirements(vkStream, rootType,
+                                   (VkMemoryRequirements*)(&forUnmarshaling->memoryRequirements));
 }
 
-void marshal_VkVideoBindMemoryKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                  const VkVideoBindMemoryKHR* forMarshaling) {
+void marshal_VkBindVideoSessionMemoryInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkBindVideoSessionMemoryInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11912,8 +14883,8 @@ void marshal_VkVideoBindMemoryKHR(VulkanStream* vkStream, VkStructureType rootTy
     vkStream->write((VkDeviceSize*)&forMarshaling->memorySize, sizeof(VkDeviceSize));
 }
 
-void unmarshal_VkVideoBindMemoryKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                    VkVideoBindMemoryKHR* forUnmarshaling) {
+void unmarshal_VkBindVideoSessionMemoryInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkBindVideoSessionMemoryInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11952,13 +14923,15 @@ void marshal_VkVideoSessionCreateInfoKHR(VulkanStream* vkStream, VkStructureType
     vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndex, sizeof(uint32_t));
     vkStream->write((VkVideoSessionCreateFlagsKHR*)&forMarshaling->flags,
                     sizeof(VkVideoSessionCreateFlagsKHR));
-    marshal_VkVideoProfileKHR(vkStream, rootType,
-                              (const VkVideoProfileKHR*)(forMarshaling->pVideoProfile));
+    marshal_VkVideoProfileInfoKHR(vkStream, rootType,
+                                  (const VkVideoProfileInfoKHR*)(forMarshaling->pVideoProfile));
     vkStream->write((VkFormat*)&forMarshaling->pictureFormat, sizeof(VkFormat));
     marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxCodedExtent));
-    vkStream->write((VkFormat*)&forMarshaling->referencePicturesFormat, sizeof(VkFormat));
-    vkStream->write((uint32_t*)&forMarshaling->maxReferencePicturesSlotsCount, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->maxReferencePicturesActiveCount, sizeof(uint32_t));
+    vkStream->write((VkFormat*)&forMarshaling->referencePictureFormat, sizeof(VkFormat));
+    vkStream->write((uint32_t*)&forMarshaling->maxDpbSlots, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxActiveReferencePictures, sizeof(uint32_t));
+    marshal_VkExtensionProperties(vkStream, rootType,
+                                  (const VkExtensionProperties*)(forMarshaling->pStdHeaderVersion));
 }
 
 void unmarshal_VkVideoSessionCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
@@ -11984,14 +14957,18 @@ void unmarshal_VkVideoSessionCreateInfoKHR(VulkanStream* vkStream, VkStructureTy
     vkStream->read((uint32_t*)&forUnmarshaling->queueFamilyIndex, sizeof(uint32_t));
     vkStream->read((VkVideoSessionCreateFlagsKHR*)&forUnmarshaling->flags,
                    sizeof(VkVideoSessionCreateFlagsKHR));
-    vkStream->alloc((void**)&forUnmarshaling->pVideoProfile, sizeof(const VkVideoProfileKHR));
-    unmarshal_VkVideoProfileKHR(vkStream, rootType,
-                                (VkVideoProfileKHR*)(forUnmarshaling->pVideoProfile));
+    vkStream->alloc((void**)&forUnmarshaling->pVideoProfile, sizeof(const VkVideoProfileInfoKHR));
+    unmarshal_VkVideoProfileInfoKHR(vkStream, rootType,
+                                    (VkVideoProfileInfoKHR*)(forUnmarshaling->pVideoProfile));
     vkStream->read((VkFormat*)&forUnmarshaling->pictureFormat, sizeof(VkFormat));
     unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxCodedExtent));
-    vkStream->read((VkFormat*)&forUnmarshaling->referencePicturesFormat, sizeof(VkFormat));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxReferencePicturesSlotsCount, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxReferencePicturesActiveCount, sizeof(uint32_t));
+    vkStream->read((VkFormat*)&forUnmarshaling->referencePictureFormat, sizeof(VkFormat));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDpbSlots, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxActiveReferencePictures, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pStdHeaderVersion,
+                    sizeof(const VkExtensionProperties));
+    unmarshal_VkExtensionProperties(vkStream, rootType,
+                                    (VkExtensionProperties*)(forUnmarshaling->pStdHeaderVersion));
 }
 
 void marshal_VkVideoSessionParametersCreateInfoKHR(
@@ -12003,6 +14980,8 @@ void marshal_VkVideoSessionParametersCreateInfoKHR(
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkVideoSessionParametersCreateFlagsKHR*)&forMarshaling->flags,
+                    sizeof(VkVideoSessionParametersCreateFlagsKHR));
     uint64_t cgen_var_0 = (uint64_t)forMarshaling->videoSessionParametersTemplate;
     vkStream->putBe64(cgen_var_0);
     uint64_t cgen_var_1 = (uint64_t)forMarshaling->videoSession;
@@ -12030,6 +15009,8 @@ void unmarshal_VkVideoSessionParametersCreateInfoKHR(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
+    vkStream->read((VkVideoSessionParametersCreateFlagsKHR*)&forUnmarshaling->flags,
+                   sizeof(VkVideoSessionParametersCreateFlagsKHR));
     forUnmarshaling->videoSessionParametersTemplate =
         (VkVideoSessionParametersKHR)vkStream->getBe64();
     forUnmarshaling->videoSession = (VkVideoSessionKHR)vkStream->getBe64();
@@ -12081,8 +15062,6 @@ void marshal_VkVideoBeginCodingInfoKHR(VulkanStream* vkStream, VkStructureType r
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
     vkStream->write((VkVideoBeginCodingFlagsKHR*)&forMarshaling->flags,
                     sizeof(VkVideoBeginCodingFlagsKHR));
-    vkStream->write((VkVideoCodingQualityPresetFlagsKHR*)&forMarshaling->codecQualityPreset,
-                    sizeof(VkVideoCodingQualityPresetFlagsKHR));
     uint64_t cgen_var_0 = (uint64_t)forMarshaling->videoSession;
     vkStream->putBe64(cgen_var_0);
     uint64_t cgen_var_1 = (uint64_t)forMarshaling->videoSessionParameters;
@@ -12090,9 +15069,9 @@ void marshal_VkVideoBeginCodingInfoKHR(VulkanStream* vkStream, VkStructureType r
     vkStream->write((uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
     if (forMarshaling) {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
-            marshal_VkVideoReferenceSlotKHR(
+            marshal_VkVideoReferenceSlotInfoKHR(
                 vkStream, rootType,
-                (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i));
+                (const VkVideoReferenceSlotInfoKHR*)(forMarshaling->pReferenceSlots + i));
         }
     }
 }
@@ -12119,18 +15098,17 @@ void unmarshal_VkVideoBeginCodingInfoKHR(VulkanStream* vkStream, VkStructureType
     }
     vkStream->read((VkVideoBeginCodingFlagsKHR*)&forUnmarshaling->flags,
                    sizeof(VkVideoBeginCodingFlagsKHR));
-    vkStream->read((VkVideoCodingQualityPresetFlagsKHR*)&forUnmarshaling->codecQualityPreset,
-                   sizeof(VkVideoCodingQualityPresetFlagsKHR));
     forUnmarshaling->videoSession = (VkVideoSessionKHR)vkStream->getBe64();
     forUnmarshaling->videoSessionParameters = (VkVideoSessionParametersKHR)vkStream->getBe64();
     vkStream->read((uint32_t*)&forUnmarshaling->referenceSlotCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pReferenceSlots,
-                    forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pReferenceSlots,
+        forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotInfoKHR));
     if (forUnmarshaling) {
         for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i) {
-            unmarshal_VkVideoReferenceSlotKHR(
+            unmarshal_VkVideoReferenceSlotInfoKHR(
                 vkStream, rootType,
-                (VkVideoReferenceSlotKHR*)(forUnmarshaling->pReferenceSlots + i));
+                (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pReferenceSlots + i));
         }
     }
 }
@@ -12209,6 +15187,78 @@ void unmarshal_VkVideoCodingControlInfoKHR(VulkanStream* vkStream, VkStructureTy
 
 #endif
 #ifdef VK_KHR_video_decode_queue
+void marshal_VkVideoDecodeCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                          const VkVideoDecodeCapabilitiesKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkVideoDecodeCapabilityFlagsKHR*)&forMarshaling->flags,
+                    sizeof(VkVideoDecodeCapabilityFlagsKHR));
+}
+
+void unmarshal_VkVideoDecodeCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                            VkVideoDecodeCapabilitiesKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkVideoDecodeCapabilityFlagsKHR*)&forUnmarshaling->flags,
+                   sizeof(VkVideoDecodeCapabilityFlagsKHR));
+}
+
+void marshal_VkVideoDecodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                       const VkVideoDecodeUsageInfoKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkVideoDecodeUsageFlagsKHR*)&forMarshaling->videoUsageHints,
+                    sizeof(VkVideoDecodeUsageFlagsKHR));
+}
+
+void unmarshal_VkVideoDecodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkVideoDecodeUsageInfoKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkVideoDecodeUsageFlagsKHR*)&forUnmarshaling->videoUsageHints,
+                   sizeof(VkVideoDecodeUsageFlagsKHR));
+}
+
 void marshal_VkVideoDecodeInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkVideoDecodeInfoKHR* forMarshaling) {
     (void)rootType;
@@ -12218,23 +15268,22 @@ void marshal_VkVideoDecodeInfoKHR(VulkanStream* vkStream, VkStructureType rootTy
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
     vkStream->write((VkVideoDecodeFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoDecodeFlagsKHR));
-    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->codedOffset));
-    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->codedExtent));
     uint64_t cgen_var_0;
     vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->srcBuffer, &cgen_var_0, 1);
     vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
     vkStream->write((VkDeviceSize*)&forMarshaling->srcBufferOffset, sizeof(VkDeviceSize));
     vkStream->write((VkDeviceSize*)&forMarshaling->srcBufferRange, sizeof(VkDeviceSize));
-    marshal_VkVideoPictureResourceKHR(
-        vkStream, rootType, (VkVideoPictureResourceKHR*)(&forMarshaling->dstPictureResource));
-    marshal_VkVideoReferenceSlotKHR(
-        vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pSetupReferenceSlot));
+    marshal_VkVideoPictureResourceInfoKHR(
+        vkStream, rootType, (VkVideoPictureResourceInfoKHR*)(&forMarshaling->dstPictureResource));
+    marshal_VkVideoReferenceSlotInfoKHR(
+        vkStream, rootType,
+        (const VkVideoReferenceSlotInfoKHR*)(forMarshaling->pSetupReferenceSlot));
     vkStream->write((uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
     if (forMarshaling) {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
-            marshal_VkVideoReferenceSlotKHR(
+            marshal_VkVideoReferenceSlotInfoKHR(
                 vkStream, rootType,
-                (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i));
+                (const VkVideoReferenceSlotInfoKHR*)(forMarshaling->pReferenceSlots + i));
         }
     }
 }
@@ -12260,61 +15309,49 @@ void unmarshal_VkVideoDecodeInfoKHR(VulkanStream* vkStream, VkStructureType root
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
     vkStream->read((VkVideoDecodeFlagsKHR*)&forUnmarshaling->flags, sizeof(VkVideoDecodeFlagsKHR));
-    unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->codedOffset));
-    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->codedExtent));
     uint64_t cgen_var_0;
     vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
     vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
                                                        (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
     vkStream->read((VkDeviceSize*)&forUnmarshaling->srcBufferOffset, sizeof(VkDeviceSize));
     vkStream->read((VkDeviceSize*)&forUnmarshaling->srcBufferRange, sizeof(VkDeviceSize));
-    unmarshal_VkVideoPictureResourceKHR(
-        vkStream, rootType, (VkVideoPictureResourceKHR*)(&forUnmarshaling->dstPictureResource));
+    unmarshal_VkVideoPictureResourceInfoKHR(
+        vkStream, rootType, (VkVideoPictureResourceInfoKHR*)(&forUnmarshaling->dstPictureResource));
     vkStream->alloc((void**)&forUnmarshaling->pSetupReferenceSlot,
-                    sizeof(const VkVideoReferenceSlotKHR));
-    unmarshal_VkVideoReferenceSlotKHR(
-        vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pSetupReferenceSlot));
+                    sizeof(const VkVideoReferenceSlotInfoKHR));
+    unmarshal_VkVideoReferenceSlotInfoKHR(
+        vkStream, rootType, (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pSetupReferenceSlot));
     vkStream->read((uint32_t*)&forUnmarshaling->referenceSlotCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pReferenceSlots,
-                    forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pReferenceSlots,
+        forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotInfoKHR));
     if (forUnmarshaling) {
         for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i) {
-            unmarshal_VkVideoReferenceSlotKHR(
+            unmarshal_VkVideoReferenceSlotInfoKHR(
                 vkStream, rootType,
-                (VkVideoReferenceSlotKHR*)(forUnmarshaling->pReferenceSlots + i));
+                (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pReferenceSlots + i));
         }
     }
 }
 
 #endif
-#ifdef VK_KHR_dynamic_rendering
-void marshal_VkRenderingAttachmentInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                          const VkRenderingAttachmentInfoKHR* forMarshaling) {
+#ifdef VK_KHR_video_decode_h264
+void marshal_VkVideoDecodeH264ProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoDecodeH264ProfileInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    uint64_t cgen_var_0;
-    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
-                                                          1);
-    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
-    vkStream->write((VkResolveModeFlagBits*)&forMarshaling->resolveMode,
-                    sizeof(VkResolveModeFlagBits));
-    uint64_t cgen_var_1;
-    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->resolveImageView,
-                                                          &cgen_var_1, 1);
-    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->write((VkImageLayout*)&forMarshaling->resolveImageLayout, sizeof(VkImageLayout));
-    vkStream->write((VkAttachmentLoadOp*)&forMarshaling->loadOp, sizeof(VkAttachmentLoadOp));
-    vkStream->write((VkAttachmentStoreOp*)&forMarshaling->storeOp, sizeof(VkAttachmentStoreOp));
-    marshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forMarshaling->clearValue));
+    vkStream->write((StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc,
+                    sizeof(StdVideoH264ProfileIdc));
+    vkStream->write((VkVideoDecodeH264PictureLayoutFlagBitsKHR*)&forMarshaling->pictureLayout,
+                    sizeof(VkVideoDecodeH264PictureLayoutFlagBitsKHR));
 }
 
-void unmarshal_VkRenderingAttachmentInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                            VkRenderingAttachmentInfoKHR* forUnmarshaling) {
+void unmarshal_VkVideoDecodeH264ProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoDecodeH264ProfileInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12333,63 +15370,28 @@ void unmarshal_VkRenderingAttachmentInfoKHR(VulkanStream* vkStream, VkStructureT
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_0;
-    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImageView(
-        &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
-    vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
-    vkStream->read((VkResolveModeFlagBits*)&forUnmarshaling->resolveMode,
-                   sizeof(VkResolveModeFlagBits));
-    uint64_t cgen_var_1;
-    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImageView(
-        &cgen_var_1, (VkImageView*)&forUnmarshaling->resolveImageView, 1);
-    vkStream->read((VkImageLayout*)&forUnmarshaling->resolveImageLayout, sizeof(VkImageLayout));
-    vkStream->read((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, sizeof(VkAttachmentLoadOp));
-    vkStream->read((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, sizeof(VkAttachmentStoreOp));
-    unmarshal_VkClearValue(vkStream, rootType, (VkClearValue*)(&forUnmarshaling->clearValue));
+    vkStream->read((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc,
+                   sizeof(StdVideoH264ProfileIdc));
+    vkStream->read((VkVideoDecodeH264PictureLayoutFlagBitsKHR*)&forUnmarshaling->pictureLayout,
+                   sizeof(VkVideoDecodeH264PictureLayoutFlagBitsKHR));
 }
 
-void marshal_VkRenderingInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                const VkRenderingInfoKHR* forMarshaling) {
+void marshal_VkVideoDecodeH264CapabilitiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoDecodeH264CapabilitiesKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkRenderingFlagsKHR*)&forMarshaling->flags, sizeof(VkRenderingFlagsKHR));
-    marshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forMarshaling->renderArea));
-    vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i) {
-            marshal_VkRenderingAttachmentInfoKHR(
-                vkStream, rootType,
-                (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pColorAttachments + i));
-        }
-    }
-    // WARNING PTR CHECK
-    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pDepthAttachment;
-    vkStream->putBe64(cgen_var_0);
-    if (forMarshaling->pDepthAttachment) {
-        marshal_VkRenderingAttachmentInfoKHR(
-            vkStream, rootType,
-            (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pDepthAttachment));
-    }
-    // WARNING PTR CHECK
-    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pStencilAttachment;
-    vkStream->putBe64(cgen_var_1);
-    if (forMarshaling->pStencilAttachment) {
-        marshal_VkRenderingAttachmentInfoKHR(
-            vkStream, rootType,
-            (const VkRenderingAttachmentInfoKHR*)(forMarshaling->pStencilAttachment));
-    }
+    vkStream->write((StdVideoH264LevelIdc*)&forMarshaling->maxLevelIdc,
+                    sizeof(StdVideoH264LevelIdc));
+    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->fieldOffsetGranularity));
 }
 
-void unmarshal_VkRenderingInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                  VkRenderingInfoKHR* forUnmarshaling) {
+void unmarshal_VkVideoDecodeH264CapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkVideoDecodeH264CapabilitiesKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12408,61 +15410,87 @@ void unmarshal_VkRenderingInfoKHR(VulkanStream* vkStream, VkStructureType rootTy
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkRenderingFlagsKHR*)&forUnmarshaling->flags, sizeof(VkRenderingFlagsKHR));
-    unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->renderArea));
-    vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pColorAttachments,
-        forUnmarshaling->colorAttachmentCount * sizeof(const VkRenderingAttachmentInfoKHR));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
-            unmarshal_VkRenderingAttachmentInfoKHR(
-                vkStream, rootType,
-                (VkRenderingAttachmentInfoKHR*)(forUnmarshaling->pColorAttachments + i));
-        }
+    vkStream->read((StdVideoH264LevelIdc*)&forUnmarshaling->maxLevelIdc,
+                   sizeof(StdVideoH264LevelIdc));
+    unmarshal_VkOffset2D(vkStream, rootType,
+                         (VkOffset2D*)(&forUnmarshaling->fieldOffsetGranularity));
+}
+
+void marshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoDecodeH264SessionParametersAddInfoKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
     }
-    // WARNING PTR CHECK
-    forUnmarshaling->pDepthAttachment =
-        (const VkRenderingAttachmentInfoKHR*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pDepthAttachment) {
-        vkStream->alloc((void**)&forUnmarshaling->pDepthAttachment,
-                        sizeof(const VkRenderingAttachmentInfoKHR));
-        unmarshal_VkRenderingAttachmentInfoKHR(
-            vkStream, rootType, (VkRenderingAttachmentInfoKHR*)(forUnmarshaling->pDepthAttachment));
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->stdSPSCount, sizeof(uint32_t));
+    vkStream->write((const StdVideoH264SequenceParameterSet*)forMarshaling->pStdSPSs,
+                    forMarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
+    vkStream->write((uint32_t*)&forMarshaling->stdPPSCount, sizeof(uint32_t));
+    vkStream->write((const StdVideoH264PictureParameterSet*)forMarshaling->pStdPPSs,
+                    forMarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
+}
+
+void unmarshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH264SessionParametersAddInfoKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
     }
-    // WARNING PTR CHECK
-    forUnmarshaling->pStencilAttachment =
-        (const VkRenderingAttachmentInfoKHR*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pStencilAttachment) {
-        vkStream->alloc((void**)&forUnmarshaling->pStencilAttachment,
-                        sizeof(const VkRenderingAttachmentInfoKHR));
-        unmarshal_VkRenderingAttachmentInfoKHR(
-            vkStream, rootType,
-            (VkRenderingAttachmentInfoKHR*)(forUnmarshaling->pStencilAttachment));
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
+    vkStream->read((uint32_t*)&forUnmarshaling->stdSPSCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pStdSPSs,
+                    forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
+    vkStream->read((StdVideoH264SequenceParameterSet*)forUnmarshaling->pStdSPSs,
+                   forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
+    vkStream->read((uint32_t*)&forUnmarshaling->stdPPSCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pStdPPSs,
+                    forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
+    vkStream->read((StdVideoH264PictureParameterSet*)forUnmarshaling->pStdPPSs,
+                   forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
 }
 
-void marshal_VkPipelineRenderingCreateInfoKHR(
+void marshal_VkVideoDecodeH264SessionParametersCreateInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPipelineRenderingCreateInfoKHR* forMarshaling) {
+    const VkVideoDecodeH264SessionParametersCreateInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
-    vkStream->write((const VkFormat*)forMarshaling->pColorAttachmentFormats,
-                    forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
-    vkStream->write((VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
-    vkStream->write((VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
+    vkStream->write((uint32_t*)&forMarshaling->maxStdSPSCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxStdPPSCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pParametersAddInfo) {
+        marshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
+            vkStream, rootType,
+            (const VkVideoDecodeH264SessionParametersAddInfoKHR*)(forMarshaling
+                                                                      ->pParametersAddInfo));
+    }
 }
 
-void unmarshal_VkPipelineRenderingCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkPipelineRenderingCreateInfoKHR* forUnmarshaling) {
+void unmarshal_VkVideoDecodeH264SessionParametersCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH264SessionParametersCreateInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12481,31 +15509,37 @@ void unmarshal_VkPipelineRenderingCreateInfoKHR(VulkanStream* vkStream, VkStruct
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pColorAttachmentFormats,
-                    forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
-    vkStream->read((VkFormat*)forUnmarshaling->pColorAttachmentFormats,
-                   forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
-    vkStream->read((VkFormat*)&forUnmarshaling->depthAttachmentFormat, sizeof(VkFormat));
-    vkStream->read((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, sizeof(VkFormat));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxStdSPSCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxStdPPSCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pParametersAddInfo =
+        (const VkVideoDecodeH264SessionParametersAddInfoKHR*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pParametersAddInfo) {
+        vkStream->alloc((void**)&forUnmarshaling->pParametersAddInfo,
+                        sizeof(const VkVideoDecodeH264SessionParametersAddInfoKHR));
+        unmarshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
+            vkStream, rootType,
+            (VkVideoDecodeH264SessionParametersAddInfoKHR*)(forUnmarshaling->pParametersAddInfo));
+    }
 }
 
-void marshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceDynamicRenderingFeaturesKHR* forMarshaling) {
+void marshal_VkVideoDecodeH264PictureInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoDecodeH264PictureInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->dynamicRendering, sizeof(VkBool32));
+    vkStream->write((const StdVideoDecodeH264PictureInfo*)forMarshaling->pStdPictureInfo,
+                    sizeof(const StdVideoDecodeH264PictureInfo));
+    vkStream->write((uint32_t*)&forMarshaling->sliceCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pSliceOffsets,
+                    forMarshaling->sliceCount * sizeof(const uint32_t));
 }
 
-void unmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceDynamicRenderingFeaturesKHR* forUnmarshaling) {
+void unmarshal_VkVideoDecodeH264PictureInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoDecodeH264PictureInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12524,32 +15558,31 @@ void unmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->dynamicRendering, sizeof(VkBool32));
+    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
+                    sizeof(const StdVideoDecodeH264PictureInfo));
+    vkStream->read((StdVideoDecodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo,
+                   sizeof(const StdVideoDecodeH264PictureInfo));
+    vkStream->read((uint32_t*)&forUnmarshaling->sliceCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pSliceOffsets,
+                    forUnmarshaling->sliceCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pSliceOffsets,
+                   forUnmarshaling->sliceCount * sizeof(const uint32_t));
 }
 
-void marshal_VkCommandBufferInheritanceRenderingInfoKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkCommandBufferInheritanceRenderingInfoKHR* forMarshaling) {
+void marshal_VkVideoDecodeH264DpbSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoDecodeH264DpbSlotInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkRenderingFlagsKHR*)&forMarshaling->flags, sizeof(VkRenderingFlagsKHR));
-    vkStream->write((uint32_t*)&forMarshaling->viewMask, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->colorAttachmentCount, sizeof(uint32_t));
-    vkStream->write((const VkFormat*)forMarshaling->pColorAttachmentFormats,
-                    forMarshaling->colorAttachmentCount * sizeof(const VkFormat));
-    vkStream->write((VkFormat*)&forMarshaling->depthAttachmentFormat, sizeof(VkFormat));
-    vkStream->write((VkFormat*)&forMarshaling->stencilAttachmentFormat, sizeof(VkFormat));
-    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
-                    sizeof(VkSampleCountFlagBits));
+    vkStream->write((const StdVideoDecodeH264ReferenceInfo*)forMarshaling->pStdReferenceInfo,
+                    sizeof(const StdVideoDecodeH264ReferenceInfo));
 }
 
-void unmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkCommandBufferInheritanceRenderingInfoKHR* forUnmarshaling) {
+void unmarshal_VkVideoDecodeH264DpbSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoDecodeH264DpbSlotInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12568,19 +15601,14 @@ void unmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkRenderingFlagsKHR*)&forUnmarshaling->flags, sizeof(VkRenderingFlagsKHR));
-    vkStream->read((uint32_t*)&forUnmarshaling->viewMask, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->colorAttachmentCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pColorAttachmentFormats,
-                    forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
-    vkStream->read((VkFormat*)forUnmarshaling->pColorAttachmentFormats,
-                   forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
-    vkStream->read((VkFormat*)&forUnmarshaling->depthAttachmentFormat, sizeof(VkFormat));
-    vkStream->read((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, sizeof(VkFormat));
-    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples,
-                   sizeof(VkSampleCountFlagBits));
+    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
+                    sizeof(const StdVideoDecodeH264ReferenceInfo));
+    vkStream->read((StdVideoDecodeH264ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
+                   sizeof(const StdVideoDecodeH264ReferenceInfo));
 }
 
+#endif
+#ifdef VK_KHR_dynamic_rendering
 void marshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
     const VkRenderingFragmentShadingRateAttachmentInfoKHR* forMarshaling) {
@@ -14694,34 +17722,299 @@ void unmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
 }
 
 #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
+#ifdef VK_KHR_video_decode_h265
+void marshal_VkVideoDecodeH265ProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoDecodeH265ProfileInfoKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((StdVideoH265ProfileIdc*)&forMarshaling->stdProfileIdc,
+                    sizeof(StdVideoH265ProfileIdc));
+}
+
+void unmarshal_VkVideoDecodeH265ProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoDecodeH265ProfileInfoKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((StdVideoH265ProfileIdc*)&forUnmarshaling->stdProfileIdc,
+                   sizeof(StdVideoH265ProfileIdc));
+}
+
+void marshal_VkVideoDecodeH265CapabilitiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoDecodeH265CapabilitiesKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((StdVideoH265LevelIdc*)&forMarshaling->maxLevelIdc,
+                    sizeof(StdVideoH265LevelIdc));
+}
+
+void unmarshal_VkVideoDecodeH265CapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkVideoDecodeH265CapabilitiesKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((StdVideoH265LevelIdc*)&forUnmarshaling->maxLevelIdc,
+                   sizeof(StdVideoH265LevelIdc));
+}
+
+void marshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoDecodeH265SessionParametersAddInfoKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->stdVPSCount, sizeof(uint32_t));
+    vkStream->write((const StdVideoH265VideoParameterSet*)forMarshaling->pStdVPSs,
+                    forMarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
+    vkStream->write((uint32_t*)&forMarshaling->stdSPSCount, sizeof(uint32_t));
+    vkStream->write((const StdVideoH265SequenceParameterSet*)forMarshaling->pStdSPSs,
+                    forMarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
+    vkStream->write((uint32_t*)&forMarshaling->stdPPSCount, sizeof(uint32_t));
+    vkStream->write((const StdVideoH265PictureParameterSet*)forMarshaling->pStdPPSs,
+                    forMarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
+}
+
+void unmarshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265SessionParametersAddInfoKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->stdVPSCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pStdVPSs,
+                    forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
+    vkStream->read((StdVideoH265VideoParameterSet*)forUnmarshaling->pStdVPSs,
+                   forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
+    vkStream->read((uint32_t*)&forUnmarshaling->stdSPSCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pStdSPSs,
+                    forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
+    vkStream->read((StdVideoH265SequenceParameterSet*)forUnmarshaling->pStdSPSs,
+                   forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
+    vkStream->read((uint32_t*)&forUnmarshaling->stdPPSCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pStdPPSs,
+                    forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
+    vkStream->read((StdVideoH265PictureParameterSet*)forUnmarshaling->pStdPPSs,
+                   forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
+}
+
+void marshal_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoDecodeH265SessionParametersCreateInfoKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->maxStdVPSCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxStdSPSCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxStdPPSCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pParametersAddInfo) {
+        marshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
+            vkStream, rootType,
+            (const VkVideoDecodeH265SessionParametersAddInfoKHR*)(forMarshaling
+                                                                      ->pParametersAddInfo));
+    }
+}
+
+void unmarshal_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265SessionParametersCreateInfoKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxStdVPSCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxStdSPSCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxStdPPSCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pParametersAddInfo =
+        (const VkVideoDecodeH265SessionParametersAddInfoKHR*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pParametersAddInfo) {
+        vkStream->alloc((void**)&forUnmarshaling->pParametersAddInfo,
+                        sizeof(const VkVideoDecodeH265SessionParametersAddInfoKHR));
+        unmarshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
+            vkStream, rootType,
+            (VkVideoDecodeH265SessionParametersAddInfoKHR*)(forUnmarshaling->pParametersAddInfo));
+    }
+}
+
+void marshal_VkVideoDecodeH265PictureInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoDecodeH265PictureInfoKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((const StdVideoDecodeH265PictureInfo*)forMarshaling->pStdPictureInfo,
+                    sizeof(const StdVideoDecodeH265PictureInfo));
+    vkStream->write((uint32_t*)&forMarshaling->sliceSegmentCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pSliceSegmentOffsets,
+                    forMarshaling->sliceSegmentCount * sizeof(const uint32_t));
+}
+
+void unmarshal_VkVideoDecodeH265PictureInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoDecodeH265PictureInfoKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
+                    sizeof(const StdVideoDecodeH265PictureInfo));
+    vkStream->read((StdVideoDecodeH265PictureInfo*)forUnmarshaling->pStdPictureInfo,
+                   sizeof(const StdVideoDecodeH265PictureInfo));
+    vkStream->read((uint32_t*)&forUnmarshaling->sliceSegmentCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pSliceSegmentOffsets,
+                    forUnmarshaling->sliceSegmentCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pSliceSegmentOffsets,
+                   forUnmarshaling->sliceSegmentCount * sizeof(const uint32_t));
+}
+
+void marshal_VkVideoDecodeH265DpbSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoDecodeH265DpbSlotInfoKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((const StdVideoDecodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo,
+                    sizeof(const StdVideoDecodeH265ReferenceInfo));
+}
+
+void unmarshal_VkVideoDecodeH265DpbSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoDecodeH265DpbSlotInfoKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
+                    sizeof(const StdVideoDecodeH265ReferenceInfo));
+    vkStream->read((StdVideoDecodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
+                   sizeof(const StdVideoDecodeH265ReferenceInfo));
+}
+
 #endif
-#ifdef VK_KHR_shader_terminate_invocation
-void marshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+#ifdef VK_KHR_global_priority
+void marshal_VkDeviceQueueGlobalPriorityCreateInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling) {
+    const VkDeviceQueueGlobalPriorityCreateInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->shaderTerminateInvocation, sizeof(VkBool32));
+    vkStream->write((VkQueueGlobalPriorityKHR*)&forMarshaling->globalPriority,
+                    sizeof(VkQueueGlobalPriorityKHR));
 }
 
-void unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forUnmarshaling) {
+    VkDeviceQueueGlobalPriorityCreateInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -14740,9 +18033,100 @@ void unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->shaderTerminateInvocation, sizeof(VkBool32));
+    vkStream->read((VkQueueGlobalPriorityKHR*)&forUnmarshaling->globalPriority,
+                   sizeof(VkQueueGlobalPriorityKHR));
+}
+
+void marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->globalPriorityQuery, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->globalPriorityQuery, sizeof(VkBool32));
 }
 
+void marshal_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkQueueFamilyGlobalPriorityPropertiesKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->priorityCount, sizeof(uint32_t));
+    vkStream->write((VkQueueGlobalPriorityKHR*)forMarshaling->priorities,
+                    VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
+}
+
+void unmarshal_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkQueueFamilyGlobalPriorityPropertiesKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->priorityCount, sizeof(uint32_t));
+    vkStream->read((VkQueueGlobalPriorityKHR*)forUnmarshaling->priorities,
+                   VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
+}
+
+#endif
+#ifdef VK_KHR_driver_properties
+#endif
+#ifdef VK_KHR_shader_float_controls
+#endif
+#ifdef VK_KHR_depth_stencil_resolve
+#endif
+#ifdef VK_KHR_swapchain_mutable_format
+#endif
+#ifdef VK_KHR_timeline_semaphore
+#endif
+#ifdef VK_KHR_vulkan_memory_model
+#endif
+#ifdef VK_KHR_shader_terminate_invocation
 #endif
 #ifdef VK_KHR_fragment_shading_rate
 void marshal_VkFragmentShadingRateAttachmentInfoKHR(
@@ -15381,22 +18765,26 @@ void unmarshal_VkPipelineExecutableInternalRepresentationKHR(
 }
 
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-void marshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forMarshaling) {
+#ifdef VK_KHR_map_memory2
+void marshal_VkMemoryMapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                const VkMemoryMapInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->shaderIntegerDotProduct, sizeof(VkBool32));
+    vkStream->write((VkMemoryMapFlags*)&forMarshaling->flags, sizeof(VkMemoryMapFlags));
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+                                                             1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
 }
 
-void unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forUnmarshaling) {
+void unmarshal_VkMemoryMapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                  VkMemoryMapInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -15415,100 +18803,32 @@ void unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->shaderIntegerDotProduct, sizeof(VkBool32));
+    vkStream->read((VkMemoryMapFlags*)&forUnmarshaling->flags, sizeof(VkMemoryMapFlags));
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
 }
 
-void marshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forMarshaling) {
+void marshal_VkMemoryUnmapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                  const VkMemoryUnmapInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitUnsignedAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitSignedAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct8BitMixedSignednessAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedSignedAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write(
-        (VkBool32*)&forMarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
-        sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitUnsignedAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitSignedAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct16BitMixedSignednessAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitUnsignedAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitSignedAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct32BitMixedSignednessAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitUnsignedAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitSignedAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->integerDotProduct64BitMixedSignednessAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write(
-        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
-        sizeof(VkBool32));
-    vkStream->write(
-        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
-        sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling
-                        ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling
-                        ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling
-                        ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write(
-        (VkBool32*)&forMarshaling
-            ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
-        sizeof(VkBool32));
-    vkStream->write(
-        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
-        sizeof(VkBool32));
-    vkStream->write(
-        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
-        sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling
-                        ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write(
-        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
-        sizeof(VkBool32));
-    vkStream->write(
-        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
-        sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling
-                        ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
-                    sizeof(VkBool32));
-    vkStream->write(
-        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
-        sizeof(VkBool32));
-    vkStream->write(
-        (VkBool32*)&forMarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
-        sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling
-                        ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
-                    sizeof(VkBool32));
+    vkStream->write((VkMemoryUnmapFlagsKHR*)&forMarshaling->flags, sizeof(VkMemoryUnmapFlagsKHR));
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+                                                             1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
 }
 
-void unmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forUnmarshaling) {
+void unmarshal_VkMemoryUnmapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                    VkMemoryUnmapInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -15527,86 +18847,16 @@ void unmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitUnsignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitSignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct8BitMixedSignednessAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedSignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read(
-        (VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
-        sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitUnsignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitSignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct16BitMixedSignednessAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitUnsignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitSignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct32BitMixedSignednessAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitUnsignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitSignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->integerDotProduct64BitMixedSignednessAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read(
-        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
-        sizeof(VkBool32));
-    vkStream->read(
-        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
-        sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling
-                       ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling
-                       ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling
-                       ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read(
-        (VkBool32*)&forUnmarshaling
-            ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
-        sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling
-                       ->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read(
-        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
-        sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling
-                       ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling
-                       ->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read(
-        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
-        sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling
-                       ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling
-                       ->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
-                   sizeof(VkBool32));
-    vkStream->read(
-        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
-        sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling
-                       ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
-                   sizeof(VkBool32));
+    vkStream->read((VkMemoryUnmapFlagsKHR*)&forUnmarshaling->flags, sizeof(VkMemoryUnmapFlagsKHR));
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
 }
 
 #endif
+#ifdef VK_KHR_shader_integer_dot_product
+#endif
 #ifdef VK_KHR_pipeline_library
 void marshal_VkPipelineLibraryCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             const VkPipelineLibraryCreateInfoKHR* forMarshaling) {
@@ -15759,26 +19009,30 @@ void marshal_VkVideoEncodeInfoKHR(VulkanStream* vkStream, VkStructureType rootTy
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
     vkStream->write((VkVideoEncodeFlagsKHR*)&forMarshaling->flags, sizeof(VkVideoEncodeFlagsKHR));
     vkStream->write((uint32_t*)&forMarshaling->qualityLevel, sizeof(uint32_t));
-    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->codedExtent));
     uint64_t cgen_var_0;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->dstBitstreamBuffer,
-                                                       &cgen_var_0, 1);
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->dstBuffer, &cgen_var_0, 1);
     vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->write((VkDeviceSize*)&forMarshaling->dstBitstreamBufferOffset, sizeof(VkDeviceSize));
-    vkStream->write((VkDeviceSize*)&forMarshaling->dstBitstreamBufferMaxRange,
-                    sizeof(VkDeviceSize));
-    marshal_VkVideoPictureResourceKHR(
-        vkStream, rootType, (VkVideoPictureResourceKHR*)(&forMarshaling->srcPictureResource));
-    marshal_VkVideoReferenceSlotKHR(
-        vkStream, rootType, (const VkVideoReferenceSlotKHR*)(forMarshaling->pSetupReferenceSlot));
+    vkStream->write((VkDeviceSize*)&forMarshaling->dstBufferOffset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->dstBufferRange, sizeof(VkDeviceSize));
+    marshal_VkVideoPictureResourceInfoKHR(
+        vkStream, rootType, (VkVideoPictureResourceInfoKHR*)(&forMarshaling->srcPictureResource));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSetupReferenceSlot;
+    vkStream->putBe64(cgen_var_1);
+    if (forMarshaling->pSetupReferenceSlot) {
+        marshal_VkVideoReferenceSlotInfoKHR(
+            vkStream, rootType,
+            (const VkVideoReferenceSlotInfoKHR*)(forMarshaling->pSetupReferenceSlot));
+    }
     vkStream->write((uint32_t*)&forMarshaling->referenceSlotCount, sizeof(uint32_t));
     if (forMarshaling) {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceSlotCount; ++i) {
-            marshal_VkVideoReferenceSlotKHR(
+            marshal_VkVideoReferenceSlotInfoKHR(
                 vkStream, rootType,
-                (const VkVideoReferenceSlotKHR*)(forMarshaling->pReferenceSlots + i));
+                (const VkVideoReferenceSlotInfoKHR*)(forMarshaling->pReferenceSlots + i));
         }
     }
+    vkStream->write((uint32_t*)&forMarshaling->precedingExternallyEncodedBytes, sizeof(uint32_t));
 }
 
 void unmarshal_VkVideoEncodeInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
@@ -15803,53 +19057,60 @@ void unmarshal_VkVideoEncodeInfoKHR(VulkanStream* vkStream, VkStructureType root
     }
     vkStream->read((VkVideoEncodeFlagsKHR*)&forUnmarshaling->flags, sizeof(VkVideoEncodeFlagsKHR));
     vkStream->read((uint32_t*)&forUnmarshaling->qualityLevel, sizeof(uint32_t));
-    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->codedExtent));
     uint64_t cgen_var_0;
     vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(
-        &cgen_var_0, (VkBuffer*)&forUnmarshaling->dstBitstreamBuffer, 1);
-    vkStream->read((VkDeviceSize*)&forUnmarshaling->dstBitstreamBufferOffset, sizeof(VkDeviceSize));
-    vkStream->read((VkDeviceSize*)&forUnmarshaling->dstBitstreamBufferMaxRange,
-                   sizeof(VkDeviceSize));
-    unmarshal_VkVideoPictureResourceKHR(
-        vkStream, rootType, (VkVideoPictureResourceKHR*)(&forUnmarshaling->srcPictureResource));
-    vkStream->alloc((void**)&forUnmarshaling->pSetupReferenceSlot,
-                    sizeof(const VkVideoReferenceSlotKHR));
-    unmarshal_VkVideoReferenceSlotKHR(
-        vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pSetupReferenceSlot));
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+                                                       (VkBuffer*)&forUnmarshaling->dstBuffer, 1);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->dstBufferOffset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->dstBufferRange, sizeof(VkDeviceSize));
+    unmarshal_VkVideoPictureResourceInfoKHR(
+        vkStream, rootType, (VkVideoPictureResourceInfoKHR*)(&forUnmarshaling->srcPictureResource));
+    // WARNING PTR CHECK
+    forUnmarshaling->pSetupReferenceSlot =
+        (const VkVideoReferenceSlotInfoKHR*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pSetupReferenceSlot) {
+        vkStream->alloc((void**)&forUnmarshaling->pSetupReferenceSlot,
+                        sizeof(const VkVideoReferenceSlotInfoKHR));
+        unmarshal_VkVideoReferenceSlotInfoKHR(
+            vkStream, rootType,
+            (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pSetupReferenceSlot));
+    }
     vkStream->read((uint32_t*)&forUnmarshaling->referenceSlotCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pReferenceSlots,
-                    forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pReferenceSlots,
+        forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotInfoKHR));
     if (forUnmarshaling) {
         for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i) {
-            unmarshal_VkVideoReferenceSlotKHR(
+            unmarshal_VkVideoReferenceSlotInfoKHR(
                 vkStream, rootType,
-                (VkVideoReferenceSlotKHR*)(forUnmarshaling->pReferenceSlots + i));
+                (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pReferenceSlots + i));
         }
     }
+    vkStream->read((uint32_t*)&forUnmarshaling->precedingExternallyEncodedBytes, sizeof(uint32_t));
 }
 
-void marshal_VkVideoEncodeRateControlInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                             const VkVideoEncodeRateControlInfoKHR* forMarshaling) {
+void marshal_VkVideoEncodeCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                          const VkVideoEncodeCapabilitiesKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkVideoEncodeRateControlFlagsKHR*)&forMarshaling->flags,
-                    sizeof(VkVideoEncodeRateControlFlagsKHR));
-    vkStream->write((VkVideoEncodeRateControlModeFlagBitsKHR*)&forMarshaling->rateControlMode,
-                    sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
-    vkStream->write((uint32_t*)&forMarshaling->averageBitrate, sizeof(uint32_t));
-    vkStream->write((uint16_t*)&forMarshaling->peakToAverageBitrateRatio, sizeof(uint16_t));
-    vkStream->write((uint16_t*)&forMarshaling->frameRateNumerator, sizeof(uint16_t));
-    vkStream->write((uint16_t*)&forMarshaling->frameRateDenominator, sizeof(uint16_t));
-    vkStream->write((uint32_t*)&forMarshaling->virtualBufferSizeInMs, sizeof(uint32_t));
+    vkStream->write((VkVideoEncodeCapabilityFlagsKHR*)&forMarshaling->flags,
+                    sizeof(VkVideoEncodeCapabilityFlagsKHR));
+    vkStream->write((VkVideoEncodeRateControlModeFlagsKHR*)&forMarshaling->rateControlModes,
+                    sizeof(VkVideoEncodeRateControlModeFlagsKHR));
+    vkStream->write((uint32_t*)&forMarshaling->maxRateControlLayers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxQualityLevels, sizeof(uint32_t));
+    marshal_VkExtent2D(vkStream, rootType,
+                       (VkExtent2D*)(&forMarshaling->inputImageDataFillAlignment));
+    vkStream->write((VkVideoEncodeFeedbackFlagsKHR*)&forMarshaling->supportedEncodeFeedbackFlags,
+                    sizeof(VkVideoEncodeFeedbackFlagsKHR));
 }
 
-void unmarshal_VkVideoEncodeRateControlInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoEncodeRateControlInfoKHR* forUnmarshaling) {
+void unmarshal_VkVideoEncodeCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                            VkVideoEncodeCapabilitiesKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -15868,37 +19129,34 @@ void unmarshal_VkVideoEncodeRateControlInfoKHR(VulkanStream* vkStream, VkStructu
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkVideoEncodeRateControlFlagsKHR*)&forUnmarshaling->flags,
-                   sizeof(VkVideoEncodeRateControlFlagsKHR));
-    vkStream->read((VkVideoEncodeRateControlModeFlagBitsKHR*)&forUnmarshaling->rateControlMode,
-                   sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
-    vkStream->read((uint32_t*)&forUnmarshaling->averageBitrate, sizeof(uint32_t));
-    vkStream->read((uint16_t*)&forUnmarshaling->peakToAverageBitrateRatio, sizeof(uint16_t));
-    vkStream->read((uint16_t*)&forUnmarshaling->frameRateNumerator, sizeof(uint16_t));
-    vkStream->read((uint16_t*)&forUnmarshaling->frameRateDenominator, sizeof(uint16_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->virtualBufferSizeInMs, sizeof(uint32_t));
+    vkStream->read((VkVideoEncodeCapabilityFlagsKHR*)&forUnmarshaling->flags,
+                   sizeof(VkVideoEncodeCapabilityFlagsKHR));
+    vkStream->read((VkVideoEncodeRateControlModeFlagsKHR*)&forUnmarshaling->rateControlModes,
+                   sizeof(VkVideoEncodeRateControlModeFlagsKHR));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxRateControlLayers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxQualityLevels, sizeof(uint32_t));
+    unmarshal_VkExtent2D(vkStream, rootType,
+                         (VkExtent2D*)(&forUnmarshaling->inputImageDataFillAlignment));
+    vkStream->read((VkVideoEncodeFeedbackFlagsKHR*)&forUnmarshaling->supportedEncodeFeedbackFlags,
+                   sizeof(VkVideoEncodeFeedbackFlagsKHR));
 }
 
-#endif
-#ifdef VK_KHR_synchronization2
-void marshal_VkMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                 const VkMemoryBarrier2KHR* forMarshaling) {
+void marshal_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask,
-                    sizeof(VkPipelineStageFlags2KHR));
-    vkStream->write((VkAccessFlags2KHR*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
-    vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask,
-                    sizeof(VkPipelineStageFlags2KHR));
-    vkStream->write((VkAccessFlags2KHR*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
+    vkStream->write((VkVideoEncodeFeedbackFlagsKHR*)&forMarshaling->encodeFeedbackFlags,
+                    sizeof(VkVideoEncodeFeedbackFlagsKHR));
 }
 
-void unmarshal_VkMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                   VkMemoryBarrier2KHR* forUnmarshaling) {
+void unmarshal_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -15917,39 +19175,28 @@ void unmarshal_VkMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootT
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->srcStageMask,
-                   sizeof(VkPipelineStageFlags2KHR));
-    vkStream->read((VkAccessFlags2KHR*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
-    vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->dstStageMask,
-                   sizeof(VkPipelineStageFlags2KHR));
-    vkStream->read((VkAccessFlags2KHR*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
+    vkStream->read((VkVideoEncodeFeedbackFlagsKHR*)&forUnmarshaling->encodeFeedbackFlags,
+                   sizeof(VkVideoEncodeFeedbackFlagsKHR));
 }
 
-void marshal_VkBufferMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                       const VkBufferMemoryBarrier2KHR* forMarshaling) {
+void marshal_VkVideoEncodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                       const VkVideoEncodeUsageInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask,
-                    sizeof(VkPipelineStageFlags2KHR));
-    vkStream->write((VkAccessFlags2KHR*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
-    vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask,
-                    sizeof(VkPipelineStageFlags2KHR));
-    vkStream->write((VkAccessFlags2KHR*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
-    vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
-    uint64_t cgen_var_0;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
-    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
-    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+    vkStream->write((VkVideoEncodeUsageFlagsKHR*)&forMarshaling->videoUsageHints,
+                    sizeof(VkVideoEncodeUsageFlagsKHR));
+    vkStream->write((VkVideoEncodeContentFlagsKHR*)&forMarshaling->videoContentHints,
+                    sizeof(VkVideoEncodeContentFlagsKHR));
+    vkStream->write((VkVideoEncodeTuningModeKHR*)&forMarshaling->tuningMode,
+                    sizeof(VkVideoEncodeTuningModeKHR));
 }
 
-void unmarshal_VkBufferMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                         VkBufferMemoryBarrier2KHR* forUnmarshaling) {
+void unmarshal_VkVideoEncodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkVideoEncodeUsageInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -15968,49 +19215,34 @@ void unmarshal_VkBufferMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->srcStageMask,
-                   sizeof(VkPipelineStageFlags2KHR));
-    vkStream->read((VkAccessFlags2KHR*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
-    vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->dstStageMask,
-                   sizeof(VkPipelineStageFlags2KHR));
-    vkStream->read((VkAccessFlags2KHR*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
-    vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
-    uint64_t cgen_var_0;
-    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
-                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
-    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
-    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+    vkStream->read((VkVideoEncodeUsageFlagsKHR*)&forUnmarshaling->videoUsageHints,
+                   sizeof(VkVideoEncodeUsageFlagsKHR));
+    vkStream->read((VkVideoEncodeContentFlagsKHR*)&forUnmarshaling->videoContentHints,
+                   sizeof(VkVideoEncodeContentFlagsKHR));
+    vkStream->read((VkVideoEncodeTuningModeKHR*)&forUnmarshaling->tuningMode,
+                   sizeof(VkVideoEncodeTuningModeKHR));
 }
 
-void marshal_VkImageMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                      const VkImageMemoryBarrier2KHR* forMarshaling) {
+void marshal_VkVideoEncodeRateControlLayerInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoEncodeRateControlLayerInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->srcStageMask,
-                    sizeof(VkPipelineStageFlags2KHR));
-    vkStream->write((VkAccessFlags2KHR*)&forMarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
-    vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->dstStageMask,
-                    sizeof(VkPipelineStageFlags2KHR));
-    vkStream->write((VkAccessFlags2KHR*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
-    vkStream->write((VkImageLayout*)&forMarshaling->oldLayout, sizeof(VkImageLayout));
-    vkStream->write((VkImageLayout*)&forMarshaling->newLayout, sizeof(VkImageLayout));
-    vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
-    uint64_t cgen_var_0;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
-    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
-    marshal_VkImageSubresourceRange(vkStream, rootType,
-                                    (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
+    vkStream->write((uint64_t*)&forMarshaling->averageBitrate, sizeof(uint64_t));
+    vkStream->write((uint64_t*)&forMarshaling->maxBitrate, sizeof(uint64_t));
+    vkStream->write((uint32_t*)&forMarshaling->frameRateNumerator, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->frameRateDenominator, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->virtualBufferSizeInMs, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->initialVirtualBufferSizeInMs, sizeof(uint32_t));
 }
 
-void unmarshal_VkImageMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                        VkImageMemoryBarrier2KHR* forUnmarshaling) {
+void unmarshal_VkVideoEncodeRateControlLayerInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeRateControlLayerInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -16029,61 +19261,38 @@ void unmarshal_VkImageMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->srcStageMask,
-                   sizeof(VkPipelineStageFlags2KHR));
-    vkStream->read((VkAccessFlags2KHR*)&forUnmarshaling->srcAccessMask, sizeof(VkAccessFlags2KHR));
-    vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->dstStageMask,
-                   sizeof(VkPipelineStageFlags2KHR));
-    vkStream->read((VkAccessFlags2KHR*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags2KHR));
-    vkStream->read((VkImageLayout*)&forUnmarshaling->oldLayout, sizeof(VkImageLayout));
-    vkStream->read((VkImageLayout*)&forUnmarshaling->newLayout, sizeof(VkImageLayout));
-    vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
-    uint64_t cgen_var_0;
-    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
-                                                      (VkImage*)&forUnmarshaling->image, 1);
-    unmarshal_VkImageSubresourceRange(
-        vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
+    vkStream->read((uint64_t*)&forUnmarshaling->averageBitrate, sizeof(uint64_t));
+    vkStream->read((uint64_t*)&forUnmarshaling->maxBitrate, sizeof(uint64_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->frameRateNumerator, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->frameRateDenominator, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->virtualBufferSizeInMs, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->initialVirtualBufferSizeInMs, sizeof(uint32_t));
 }
 
-void marshal_VkDependencyInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                 const VkDependencyInfoKHR* forMarshaling) {
+void marshal_VkVideoEncodeRateControlInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoEncodeRateControlInfoKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkDependencyFlags*)&forMarshaling->dependencyFlags, sizeof(VkDependencyFlags));
-    vkStream->write((uint32_t*)&forMarshaling->memoryBarrierCount, sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->memoryBarrierCount; ++i) {
-            marshal_VkMemoryBarrier2KHR(
-                vkStream, rootType,
-                (const VkMemoryBarrier2KHR*)(forMarshaling->pMemoryBarriers + i));
-        }
-    }
-    vkStream->write((uint32_t*)&forMarshaling->bufferMemoryBarrierCount, sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->bufferMemoryBarrierCount; ++i) {
-            marshal_VkBufferMemoryBarrier2KHR(
-                vkStream, rootType,
-                (const VkBufferMemoryBarrier2KHR*)(forMarshaling->pBufferMemoryBarriers + i));
-        }
-    }
-    vkStream->write((uint32_t*)&forMarshaling->imageMemoryBarrierCount, sizeof(uint32_t));
+    vkStream->write((VkVideoEncodeRateControlFlagsKHR*)&forMarshaling->flags,
+                    sizeof(VkVideoEncodeRateControlFlagsKHR));
+    vkStream->write((VkVideoEncodeRateControlModeFlagBitsKHR*)&forMarshaling->rateControlMode,
+                    sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
+    vkStream->write((uint32_t*)&forMarshaling->layerCount, sizeof(uint32_t));
     if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->imageMemoryBarrierCount; ++i) {
-            marshal_VkImageMemoryBarrier2KHR(
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->layerCount; ++i) {
+            marshal_VkVideoEncodeRateControlLayerInfoKHR(
                 vkStream, rootType,
-                (const VkImageMemoryBarrier2KHR*)(forMarshaling->pImageMemoryBarriers + i));
+                (const VkVideoEncodeRateControlLayerInfoKHR*)(forMarshaling->pLayers + i));
         }
     }
 }
 
-void unmarshal_VkDependencyInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                   VkDependencyInfoKHR* forUnmarshaling) {
+void unmarshal_VkVideoEncodeRateControlInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoEncodeRateControlInfoKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -16102,106 +19311,41 @@ void unmarshal_VkDependencyInfoKHR(VulkanStream* vkStream, VkStructureType rootT
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkDependencyFlags*)&forUnmarshaling->dependencyFlags,
-                   sizeof(VkDependencyFlags));
-    vkStream->read((uint32_t*)&forUnmarshaling->memoryBarrierCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pMemoryBarriers,
-                    forUnmarshaling->memoryBarrierCount * sizeof(const VkMemoryBarrier2KHR));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->memoryBarrierCount; ++i) {
-            unmarshal_VkMemoryBarrier2KHR(
-                vkStream, rootType, (VkMemoryBarrier2KHR*)(forUnmarshaling->pMemoryBarriers + i));
-        }
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->bufferMemoryBarrierCount, sizeof(uint32_t));
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pBufferMemoryBarriers,
-        forUnmarshaling->bufferMemoryBarrierCount * sizeof(const VkBufferMemoryBarrier2KHR));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferMemoryBarrierCount; ++i) {
-            unmarshal_VkBufferMemoryBarrier2KHR(
-                vkStream, rootType,
-                (VkBufferMemoryBarrier2KHR*)(forUnmarshaling->pBufferMemoryBarriers + i));
-        }
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->imageMemoryBarrierCount, sizeof(uint32_t));
+    vkStream->read((VkVideoEncodeRateControlFlagsKHR*)&forUnmarshaling->flags,
+                   sizeof(VkVideoEncodeRateControlFlagsKHR));
+    vkStream->read((VkVideoEncodeRateControlModeFlagBitsKHR*)&forUnmarshaling->rateControlMode,
+                   sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
+    vkStream->read((uint32_t*)&forUnmarshaling->layerCount, sizeof(uint32_t));
     vkStream->alloc(
-        (void**)&forUnmarshaling->pImageMemoryBarriers,
-        forUnmarshaling->imageMemoryBarrierCount * sizeof(const VkImageMemoryBarrier2KHR));
+        (void**)&forUnmarshaling->pLayers,
+        forUnmarshaling->layerCount * sizeof(const VkVideoEncodeRateControlLayerInfoKHR));
     if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageMemoryBarrierCount; ++i) {
-            unmarshal_VkImageMemoryBarrier2KHR(
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->layerCount; ++i) {
+            unmarshal_VkVideoEncodeRateControlLayerInfoKHR(
                 vkStream, rootType,
-                (VkImageMemoryBarrier2KHR*)(forUnmarshaling->pImageMemoryBarriers + i));
+                (VkVideoEncodeRateControlLayerInfoKHR*)(forUnmarshaling->pLayers + i));
         }
     }
 }
 
-void marshal_VkSemaphoreSubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                      const VkSemaphoreSubmitInfoKHR* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    uint64_t cgen_var_0;
-    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
-                                                          1);
-    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->write((uint64_t*)&forMarshaling->value, sizeof(uint64_t));
-    vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->stageMask,
-                    sizeof(VkPipelineStageFlags2KHR));
-    vkStream->write((uint32_t*)&forMarshaling->deviceIndex, sizeof(uint32_t));
-}
-
-void unmarshal_VkSemaphoreSubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                        VkSemaphoreSubmitInfoKHR* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    uint64_t cgen_var_0;
-    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
-        &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
-    vkStream->read((uint64_t*)&forUnmarshaling->value, sizeof(uint64_t));
-    vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->stageMask,
-                   sizeof(VkPipelineStageFlags2KHR));
-    vkStream->read((uint32_t*)&forUnmarshaling->deviceIndex, sizeof(uint32_t));
-}
-
-void marshal_VkCommandBufferSubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                          const VkCommandBufferSubmitInfoKHR* forMarshaling) {
+#endif
+#ifdef VK_KHR_synchronization2
+void marshal_VkQueueFamilyCheckpointProperties2NV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkQueueFamilyCheckpointProperties2NV* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    uint64_t cgen_var_0;
-    vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&forMarshaling->commandBuffer,
-                                                              &cgen_var_0, 1);
-    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
+    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->checkpointExecutionStageMask,
+                    sizeof(VkPipelineStageFlags2));
 }
 
-void unmarshal_VkCommandBufferSubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                            VkCommandBufferSubmitInfoKHR* forUnmarshaling) {
+void unmarshal_VkQueueFamilyCheckpointProperties2NV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkQueueFamilyCheckpointProperties2NV* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -16220,50 +19364,29 @@ void unmarshal_VkCommandBufferSubmitInfoKHR(VulkanStream* vkStream, VkStructureT
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_0;
-    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(
-        &cgen_var_0, (VkCommandBuffer*)&forUnmarshaling->commandBuffer, 1);
-    vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
+    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->checkpointExecutionStageMask,
+                   sizeof(VkPipelineStageFlags2));
 }
 
-void marshal_VkSubmitInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                              const VkSubmitInfo2KHR* forMarshaling) {
+void marshal_VkCheckpointData2NV(VulkanStream* vkStream, VkStructureType rootType,
+                                 const VkCheckpointData2NV* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkSubmitFlagsKHR*)&forMarshaling->flags, sizeof(VkSubmitFlagsKHR));
-    vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreInfoCount, sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->waitSemaphoreInfoCount; ++i) {
-            marshal_VkSemaphoreSubmitInfoKHR(
-                vkStream, rootType,
-                (const VkSemaphoreSubmitInfoKHR*)(forMarshaling->pWaitSemaphoreInfos + i));
-        }
-    }
-    vkStream->write((uint32_t*)&forMarshaling->commandBufferInfoCount, sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->commandBufferInfoCount; ++i) {
-            marshal_VkCommandBufferSubmitInfoKHR(
-                vkStream, rootType,
-                (const VkCommandBufferSubmitInfoKHR*)(forMarshaling->pCommandBufferInfos + i));
-        }
-    }
-    vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreInfoCount, sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->signalSemaphoreInfoCount; ++i) {
-            marshal_VkSemaphoreSubmitInfoKHR(
-                vkStream, rootType,
-                (const VkSemaphoreSubmitInfoKHR*)(forMarshaling->pSignalSemaphoreInfos + i));
-        }
+    vkStream->write((VkPipelineStageFlags2*)&forMarshaling->stage, sizeof(VkPipelineStageFlags2));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pCheckpointMarker) {
+        vkStream->write((void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
     }
 }
 
-void unmarshal_VkSubmitInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                VkSubmitInfo2KHR* forUnmarshaling) {
+void unmarshal_VkCheckpointData2NV(VulkanStream* vkStream, VkStructureType rootType,
+                                   VkCheckpointData2NV* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -16282,57 +19405,32 @@ void unmarshal_VkSubmitInfo2KHR(VulkanStream* vkStream, VkStructureType rootType
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkSubmitFlagsKHR*)&forUnmarshaling->flags, sizeof(VkSubmitFlagsKHR));
-    vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreInfoCount, sizeof(uint32_t));
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pWaitSemaphoreInfos,
-        forUnmarshaling->waitSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfoKHR));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->waitSemaphoreInfoCount; ++i) {
-            unmarshal_VkSemaphoreSubmitInfoKHR(
-                vkStream, rootType,
-                (VkSemaphoreSubmitInfoKHR*)(forUnmarshaling->pWaitSemaphoreInfos + i));
-        }
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->commandBufferInfoCount, sizeof(uint32_t));
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pCommandBufferInfos,
-        forUnmarshaling->commandBufferInfoCount * sizeof(const VkCommandBufferSubmitInfoKHR));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->commandBufferInfoCount; ++i) {
-            unmarshal_VkCommandBufferSubmitInfoKHR(
-                vkStream, rootType,
-                (VkCommandBufferSubmitInfoKHR*)(forUnmarshaling->pCommandBufferInfos + i));
-        }
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->signalSemaphoreInfoCount, sizeof(uint32_t));
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pSignalSemaphoreInfos,
-        forUnmarshaling->signalSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfoKHR));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->signalSemaphoreInfoCount; ++i) {
-            unmarshal_VkSemaphoreSubmitInfoKHR(
-                vkStream, rootType,
-                (VkSemaphoreSubmitInfoKHR*)(forUnmarshaling->pSignalSemaphoreInfos + i));
-        }
+    vkStream->read((VkPipelineStageFlags2*)&forUnmarshaling->stage, sizeof(VkPipelineStageFlags2));
+    // WARNING PTR CHECK
+    forUnmarshaling->pCheckpointMarker = (void*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pCheckpointMarker) {
+        vkStream->alloc((void**)&forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
+        vkStream->read((void*)forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
     }
 }
 
-void marshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
+#endif
+#ifdef VK_KHR_fragment_shader_barycentric
+void marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceSynchronization2FeaturesKHR* forMarshaling) {
+    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->synchronization2, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->fragmentShaderBarycentric, sizeof(VkBool32));
 }
 
-void unmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
+void unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceSynchronization2FeaturesKHR* forUnmarshaling) {
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -16351,25 +19449,25 @@ void unmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->synchronization2, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShaderBarycentric, sizeof(VkBool32));
 }
 
-void marshal_VkQueueFamilyCheckpointProperties2NV(
+void marshal_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkQueueFamilyCheckpointProperties2NV* forMarshaling) {
+    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->checkpointExecutionStageMask,
-                    sizeof(VkPipelineStageFlags2KHR));
+    vkStream->write((VkBool32*)&forMarshaling->triStripVertexOrderIndependentOfProvokingVertex,
+                    sizeof(VkBool32));
 }
 
-void unmarshal_VkQueueFamilyCheckpointProperties2NV(
+void unmarshal_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkQueueFamilyCheckpointProperties2NV* forUnmarshaling) {
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -16388,56 +19486,8 @@ void unmarshal_VkQueueFamilyCheckpointProperties2NV(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->checkpointExecutionStageMask,
-                   sizeof(VkPipelineStageFlags2KHR));
-}
-
-void marshal_VkCheckpointData2NV(VulkanStream* vkStream, VkStructureType rootType,
-                                 const VkCheckpointData2NV* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkPipelineStageFlags2KHR*)&forMarshaling->stage,
-                    sizeof(VkPipelineStageFlags2KHR));
-    // WARNING PTR CHECK
-    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
-    vkStream->putBe64(cgen_var_0);
-    if (forMarshaling->pCheckpointMarker) {
-        vkStream->write((void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
-    }
-}
-
-void unmarshal_VkCheckpointData2NV(VulkanStream* vkStream, VkStructureType rootType,
-                                   VkCheckpointData2NV* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkPipelineStageFlags2KHR*)&forUnmarshaling->stage,
-                   sizeof(VkPipelineStageFlags2KHR));
-    // WARNING PTR CHECK
-    forUnmarshaling->pCheckpointMarker = (void*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pCheckpointMarker) {
-        vkStream->alloc((void**)&forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
-        vkStream->read((void*)forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
-    }
+    vkStream->read((VkBool32*)&forUnmarshaling->triStripVertexOrderIndependentOfProvokingVertex,
+                   sizeof(VkBool32));
 }
 
 #endif
@@ -16480,44 +19530,6 @@ void unmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
-void marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->shaderZeroInitializeWorkgroupMemory,
-                    sizeof(VkBool32));
-}
-
-void unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkBool32*)&forUnmarshaling->shaderZeroInitializeWorkgroupMemory,
-                   sizeof(VkBool32));
-}
-
 #endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
 void marshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
@@ -16570,531 +19582,27 @@ void unmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_copy_commands2
-void marshal_VkBufferCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                              const VkBufferCopy2KHR* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkDeviceSize*)&forMarshaling->srcOffset, sizeof(VkDeviceSize));
-    vkStream->write((VkDeviceSize*)&forMarshaling->dstOffset, sizeof(VkDeviceSize));
-    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
-}
-
-void unmarshal_VkBufferCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                VkBufferCopy2KHR* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkDeviceSize*)&forUnmarshaling->srcOffset, sizeof(VkDeviceSize));
-    vkStream->read((VkDeviceSize*)&forUnmarshaling->dstOffset, sizeof(VkDeviceSize));
-    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
-}
-
-void marshal_VkCopyBufferInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                  const VkCopyBufferInfo2KHR* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    uint64_t cgen_var_0;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->srcBuffer, &cgen_var_0, 1);
-    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
-    uint64_t cgen_var_1;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->dstBuffer, &cgen_var_1, 1);
-    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
-            marshal_VkBufferCopy2KHR(vkStream, rootType,
-                                     (const VkBufferCopy2KHR*)(forMarshaling->pRegions + i));
-        }
-    }
-}
-
-void unmarshal_VkCopyBufferInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                    VkCopyBufferInfo2KHR* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    uint64_t cgen_var_0;
-    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
-                                                       (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
-    uint64_t cgen_var_1;
-    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
-                                                       (VkBuffer*)&forUnmarshaling->dstBuffer, 1);
-    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pRegions,
-                    forUnmarshaling->regionCount * sizeof(const VkBufferCopy2KHR));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
-            unmarshal_VkBufferCopy2KHR(vkStream, rootType,
-                                       (VkBufferCopy2KHR*)(forUnmarshaling->pRegions + i));
-        }
-    }
-}
-
-void marshal_VkImageCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                             const VkImageCopy2KHR* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    marshal_VkImageSubresourceLayers(vkStream, rootType,
-                                     (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
-    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
-    marshal_VkImageSubresourceLayers(vkStream, rootType,
-                                     (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
-    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset));
-    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
-}
-
-void unmarshal_VkImageCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                               VkImageCopy2KHR* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    unmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
-    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
-    unmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
-    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset));
-    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
-}
-
-void marshal_VkCopyImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                 const VkCopyImageInfo2KHR* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    uint64_t cgen_var_0;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
-    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
-    uint64_t cgen_var_1;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
-    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
-    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
-            marshal_VkImageCopy2KHR(vkStream, rootType,
-                                    (const VkImageCopy2KHR*)(forMarshaling->pRegions + i));
-        }
-    }
-}
-
-void unmarshal_VkCopyImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                   VkCopyImageInfo2KHR* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    uint64_t cgen_var_0;
-    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
-                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
-    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
-    uint64_t cgen_var_1;
-    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
-                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
-    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
-    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pRegions,
-                    forUnmarshaling->regionCount * sizeof(const VkImageCopy2KHR));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
-            unmarshal_VkImageCopy2KHR(vkStream, rootType,
-                                      (VkImageCopy2KHR*)(forUnmarshaling->pRegions + i));
-        }
-    }
-}
-
-void marshal_VkBufferImageCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                   const VkBufferImageCopy2KHR* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkDeviceSize*)&forMarshaling->bufferOffset, sizeof(VkDeviceSize));
-    vkStream->write((uint32_t*)&forMarshaling->bufferRowLength, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
-    marshal_VkImageSubresourceLayers(vkStream, rootType,
-                                     (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
-    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
-    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
-}
-
-void unmarshal_VkBufferImageCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                     VkBufferImageCopy2KHR* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkDeviceSize*)&forUnmarshaling->bufferOffset, sizeof(VkDeviceSize));
-    vkStream->read((uint32_t*)&forUnmarshaling->bufferRowLength, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->bufferImageHeight, sizeof(uint32_t));
-    unmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
-    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
-    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
-}
-
-void marshal_VkCopyBufferToImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                         const VkCopyBufferToImageInfo2KHR* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    uint64_t cgen_var_0;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->srcBuffer, &cgen_var_0, 1);
-    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
-    uint64_t cgen_var_1;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
-    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
-    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
-            marshal_VkBufferImageCopy2KHR(
-                vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i));
-        }
-    }
-}
-
-void unmarshal_VkCopyBufferToImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkCopyBufferToImageInfo2KHR* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    uint64_t cgen_var_0;
-    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
-                                                       (VkBuffer*)&forUnmarshaling->srcBuffer, 1);
-    uint64_t cgen_var_1;
-    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
-                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
-    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
-    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pRegions,
-                    forUnmarshaling->regionCount * sizeof(const VkBufferImageCopy2KHR));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
-            unmarshal_VkBufferImageCopy2KHR(
-                vkStream, rootType, (VkBufferImageCopy2KHR*)(forUnmarshaling->pRegions + i));
-        }
-    }
-}
-
-void marshal_VkCopyImageToBufferInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                         const VkCopyImageToBufferInfo2KHR* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    uint64_t cgen_var_0;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
-    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
-    uint64_t cgen_var_1;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->dstBuffer, &cgen_var_1, 1);
-    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
-            marshal_VkBufferImageCopy2KHR(
-                vkStream, rootType, (const VkBufferImageCopy2KHR*)(forMarshaling->pRegions + i));
-        }
-    }
-}
-
-void unmarshal_VkCopyImageToBufferInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkCopyImageToBufferInfo2KHR* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    uint64_t cgen_var_0;
-    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
-                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
-    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
-    uint64_t cgen_var_1;
-    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_1,
-                                                       (VkBuffer*)&forUnmarshaling->dstBuffer, 1);
-    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pRegions,
-                    forUnmarshaling->regionCount * sizeof(const VkBufferImageCopy2KHR));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
-            unmarshal_VkBufferImageCopy2KHR(
-                vkStream, rootType, (VkBufferImageCopy2KHR*)(forUnmarshaling->pRegions + i));
-        }
-    }
-}
-
-void marshal_VkImageBlit2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                             const VkImageBlit2KHR* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    marshal_VkImageSubresourceLayers(vkStream, rootType,
-                                     (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->srcOffsets + i));
-    }
-    marshal_VkImageSubresourceLayers(vkStream, rootType,
-                                     (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forMarshaling->dstOffsets + i));
-    }
-}
-
-void unmarshal_VkImageBlit2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                               VkImageBlit2KHR* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    unmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->srcOffsets + i));
-    }
-    unmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(forUnmarshaling->dstOffsets + i));
-    }
-}
-
-void marshal_VkBlitImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                 const VkBlitImageInfo2KHR* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    uint64_t cgen_var_0;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
-    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
-    uint64_t cgen_var_1;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
-    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
-    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
-            marshal_VkImageBlit2KHR(vkStream, rootType,
-                                    (const VkImageBlit2KHR*)(forMarshaling->pRegions + i));
-        }
-    }
-    vkStream->write((VkFilter*)&forMarshaling->filter, sizeof(VkFilter));
-}
-
-void unmarshal_VkBlitImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                   VkBlitImageInfo2KHR* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    uint64_t cgen_var_0;
-    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
-                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
-    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
-    uint64_t cgen_var_1;
-    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
-                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
-    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
-    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pRegions,
-                    forUnmarshaling->regionCount * sizeof(const VkImageBlit2KHR));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
-            unmarshal_VkImageBlit2KHR(vkStream, rootType,
-                                      (VkImageBlit2KHR*)(forUnmarshaling->pRegions + i));
-        }
-    }
-    vkStream->read((VkFilter*)&forUnmarshaling->filter, sizeof(VkFilter));
-}
-
-void marshal_VkImageResolve2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                const VkImageResolve2KHR* forMarshaling) {
+#endif
+#ifdef VK_KHR_format_feature_flags2
+#endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+void marshal_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    marshal_VkImageSubresourceLayers(vkStream, rootType,
-                                     (VkImageSubresourceLayers*)(&forMarshaling->srcSubresource));
-    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->srcOffset));
-    marshal_VkImageSubresourceLayers(vkStream, rootType,
-                                     (VkImageSubresourceLayers*)(&forMarshaling->dstSubresource));
-    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->dstOffset));
-    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->extent));
+    vkStream->write((VkBool32*)&forMarshaling->rayTracingMaintenance1, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->rayTracingPipelineTraceRaysIndirect2,
+                    sizeof(VkBool32));
 }
 
-void unmarshal_VkImageResolve2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                  VkImageResolve2KHR* forUnmarshaling) {
+void unmarshal_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -17113,144 +19621,89 @@ void unmarshal_VkImageResolve2KHR(VulkanStream* vkStream, VkStructureType rootTy
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    unmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource));
-    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset));
-    unmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource));
-    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset));
-    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent));
+    vkStream->read((VkBool32*)&forUnmarshaling->rayTracingMaintenance1, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPipelineTraceRaysIndirect2,
+                   sizeof(VkBool32));
 }
 
-void marshal_VkResolveImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                    const VkResolveImageInfo2KHR* forMarshaling) {
+void marshal_VkTraceRaysIndirectCommand2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkTraceRaysIndirectCommand2KHR* forMarshaling) {
     (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    uint64_t cgen_var_0;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->srcImage, &cgen_var_0, 1);
-    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->write((VkImageLayout*)&forMarshaling->srcImageLayout, sizeof(VkImageLayout));
-    uint64_t cgen_var_1;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->dstImage, &cgen_var_1, 1);
-    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->write((VkImageLayout*)&forMarshaling->dstImageLayout, sizeof(VkImageLayout));
-    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
-            marshal_VkImageResolve2KHR(vkStream, rootType,
-                                       (const VkImageResolve2KHR*)(forMarshaling->pRegions + i));
-        }
-    }
+    vkStream->write((VkDeviceAddress*)&forMarshaling->raygenShaderRecordAddress,
+                    sizeof(VkDeviceAddress));
+    vkStream->write((VkDeviceSize*)&forMarshaling->raygenShaderRecordSize, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceAddress*)&forMarshaling->missShaderBindingTableAddress,
+                    sizeof(VkDeviceAddress));
+    vkStream->write((VkDeviceSize*)&forMarshaling->missShaderBindingTableSize,
+                    sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->missShaderBindingTableStride,
+                    sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceAddress*)&forMarshaling->hitShaderBindingTableAddress,
+                    sizeof(VkDeviceAddress));
+    vkStream->write((VkDeviceSize*)&forMarshaling->hitShaderBindingTableSize, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->hitShaderBindingTableStride,
+                    sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceAddress*)&forMarshaling->callableShaderBindingTableAddress,
+                    sizeof(VkDeviceAddress));
+    vkStream->write((VkDeviceSize*)&forMarshaling->callableShaderBindingTableSize,
+                    sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->callableShaderBindingTableStride,
+                    sizeof(VkDeviceSize));
+    vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->depth, sizeof(uint32_t));
 }
 
-void unmarshal_VkResolveImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                      VkResolveImageInfo2KHR* forUnmarshaling) {
+void unmarshal_VkTraceRaysIndirectCommand2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkTraceRaysIndirectCommand2KHR* forUnmarshaling) {
     (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    uint64_t cgen_var_0;
-    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
-                                                      (VkImage*)&forUnmarshaling->srcImage, 1);
-    vkStream->read((VkImageLayout*)&forUnmarshaling->srcImageLayout, sizeof(VkImageLayout));
-    uint64_t cgen_var_1;
-    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_1,
-                                                      (VkImage*)&forUnmarshaling->dstImage, 1);
-    vkStream->read((VkImageLayout*)&forUnmarshaling->dstImageLayout, sizeof(VkImageLayout));
-    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pRegions,
-                    forUnmarshaling->regionCount * sizeof(const VkImageResolve2KHR));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
-            unmarshal_VkImageResolve2KHR(vkStream, rootType,
-                                         (VkImageResolve2KHR*)(forUnmarshaling->pRegions + i));
-        }
-    }
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->raygenShaderRecordAddress,
+                   sizeof(VkDeviceAddress));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->raygenShaderRecordSize, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->missShaderBindingTableAddress,
+                   sizeof(VkDeviceAddress));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->missShaderBindingTableSize,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->missShaderBindingTableStride,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->hitShaderBindingTableAddress,
+                   sizeof(VkDeviceAddress));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->hitShaderBindingTableSize,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->hitShaderBindingTableStride,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->callableShaderBindingTableAddress,
+                   sizeof(VkDeviceAddress));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->callableShaderBindingTableSize,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->callableShaderBindingTableStride,
+                   sizeof(VkDeviceSize));
+    vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->depth, sizeof(uint32_t));
 }
 
 #endif
-#ifdef VK_KHR_format_feature_flags2
-void marshal_VkFormatProperties3KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                    const VkFormatProperties3KHR* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->linearTilingFeatures,
-                    sizeof(VkFormatFeatureFlags2KHR));
-    vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->optimalTilingFeatures,
-                    sizeof(VkFormatFeatureFlags2KHR));
-    vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->bufferFeatures,
-                    sizeof(VkFormatFeatureFlags2KHR));
-}
-
-void unmarshal_VkFormatProperties3KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                      VkFormatProperties3KHR* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->linearTilingFeatures,
-                   sizeof(VkFormatFeatureFlags2KHR));
-    vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->optimalTilingFeatures,
-                   sizeof(VkFormatFeatureFlags2KHR));
-    vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->bufferFeatures,
-                   sizeof(VkFormatFeatureFlags2KHR));
-}
-
+#ifdef VK_KHR_portability_enumeration
 #endif
 #ifdef VK_KHR_maintenance4
-void marshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+void marshal_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceMaintenance4FeaturesKHR* forMarshaling) {
+    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->maintenance4, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->rayTracingPositionFetch, sizeof(VkBool32));
 }
 
-void unmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
+void unmarshal_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceMaintenance4FeaturesKHR* forUnmarshaling) {
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -17269,61 +19722,48 @@ void unmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->maintenance4, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->rayTracingPositionFetch, sizeof(VkBool32));
 }
 
-void marshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceMaintenance4PropertiesKHR* forMarshaling) {
+#endif
+#ifdef VK_ANDROID_native_buffer
+void marshal_VkNativeBufferUsage2ANDROID(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkNativeBufferUsage2ANDROID* forMarshaling) {
     (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkDeviceSize*)&forMarshaling->maxBufferSize, sizeof(VkDeviceSize));
+    vkStream->write((uint64_t*)&forMarshaling->consumer, sizeof(uint64_t));
+    vkStream->write((uint64_t*)&forMarshaling->producer, sizeof(uint64_t));
 }
 
-void unmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceMaintenance4PropertiesKHR* forUnmarshaling) {
+void unmarshal_VkNativeBufferUsage2ANDROID(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkNativeBufferUsage2ANDROID* forUnmarshaling) {
     (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxBufferSize, sizeof(VkDeviceSize));
+    vkStream->read((uint64_t*)&forUnmarshaling->consumer, sizeof(uint64_t));
+    vkStream->read((uint64_t*)&forUnmarshaling->producer, sizeof(uint64_t));
 }
 
-void marshal_VkDeviceBufferMemoryRequirementsKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkDeviceBufferMemoryRequirementsKHR* forMarshaling) {
+void marshal_VkNativeBufferANDROID(VulkanStream* vkStream, VkStructureType rootType,
+                                   const VkNativeBufferANDROID* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    marshal_VkBufferCreateInfo(vkStream, rootType,
-                               (const VkBufferCreateInfo*)(forMarshaling->pCreateInfo));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->handle;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->handle) {
+        vkStream->write((const uint32_t*)forMarshaling->handle, sizeof(const uint32_t));
+    }
+    vkStream->write((int*)&forMarshaling->stride, sizeof(int));
+    vkStream->write((int*)&forMarshaling->format, sizeof(int));
+    vkStream->write((int*)&forMarshaling->usage, sizeof(int));
+    marshal_VkNativeBufferUsage2ANDROID(vkStream, rootType,
+                                        (VkNativeBufferUsage2ANDROID*)(&forMarshaling->usage2));
 }
 
-void unmarshal_VkDeviceBufferMemoryRequirementsKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceBufferMemoryRequirementsKHR* forUnmarshaling) {
+void unmarshal_VkNativeBufferANDROID(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkNativeBufferANDROID* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -17342,29 +19782,35 @@ void unmarshal_VkDeviceBufferMemoryRequirementsKHR(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->alloc((void**)&forUnmarshaling->pCreateInfo, sizeof(const VkBufferCreateInfo));
-    unmarshal_VkBufferCreateInfo(vkStream, rootType,
-                                 (VkBufferCreateInfo*)(forUnmarshaling->pCreateInfo));
+    // WARNING PTR CHECK
+    forUnmarshaling->handle = (const uint32_t*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->handle) {
+        vkStream->alloc((void**)&forUnmarshaling->handle, sizeof(const uint32_t));
+        vkStream->read((uint32_t*)forUnmarshaling->handle, sizeof(const uint32_t));
+    }
+    vkStream->read((int*)&forUnmarshaling->stride, sizeof(int));
+    vkStream->read((int*)&forUnmarshaling->format, sizeof(int));
+    vkStream->read((int*)&forUnmarshaling->usage, sizeof(int));
+    unmarshal_VkNativeBufferUsage2ANDROID(vkStream, rootType,
+                                          (VkNativeBufferUsage2ANDROID*)(&forUnmarshaling->usage2));
 }
 
-void marshal_VkDeviceImageMemoryRequirementsKHR(
+void marshal_VkSwapchainImageCreateInfoANDROID(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkDeviceImageMemoryRequirementsKHR* forMarshaling) {
+    const VkSwapchainImageCreateInfoANDROID* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    marshal_VkImageCreateInfo(vkStream, rootType,
-                              (const VkImageCreateInfo*)(forMarshaling->pCreateInfo));
-    vkStream->write((VkImageAspectFlagBits*)&forMarshaling->planeAspect,
-                    sizeof(VkImageAspectFlagBits));
+    vkStream->write((VkSwapchainImageUsageFlagsANDROID*)&forMarshaling->usage,
+                    sizeof(VkSwapchainImageUsageFlagsANDROID));
 }
 
-void unmarshal_VkDeviceImageMemoryRequirementsKHR(
+void unmarshal_VkSwapchainImageCreateInfoANDROID(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceImageMemoryRequirementsKHR* forUnmarshaling) {
+    VkSwapchainImageCreateInfoANDROID* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -17383,38 +19829,25 @@ void unmarshal_VkDeviceImageMemoryRequirementsKHR(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->alloc((void**)&forUnmarshaling->pCreateInfo, sizeof(const VkImageCreateInfo));
-    unmarshal_VkImageCreateInfo(vkStream, rootType,
-                                (VkImageCreateInfo*)(forUnmarshaling->pCreateInfo));
-    vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect,
-                   sizeof(VkImageAspectFlagBits));
+    vkStream->read((VkSwapchainImageUsageFlagsANDROID*)&forUnmarshaling->usage,
+                   sizeof(VkSwapchainImageUsageFlagsANDROID));
 }
 
-#endif
-#ifdef VK_ANDROID_native_buffer
-void marshal_VkNativeBufferANDROID(VulkanStream* vkStream, VkStructureType rootType,
-                                   const VkNativeBufferANDROID* forMarshaling) {
+void marshal_VkPhysicalDevicePresentationPropertiesANDROID(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePresentationPropertiesANDROID* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    // WARNING PTR CHECK
-    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->handle;
-    vkStream->putBe64(cgen_var_0);
-    if (forMarshaling->handle) {
-        vkStream->write((const uint32_t*)forMarshaling->handle, sizeof(const uint32_t));
-    }
-    vkStream->write((int*)&forMarshaling->stride, sizeof(int));
-    vkStream->write((int*)&forMarshaling->format, sizeof(int));
-    vkStream->write((int*)&forMarshaling->usage, sizeof(int));
-    vkStream->write((uint64_t*)&forMarshaling->consumer, sizeof(uint64_t));
-    vkStream->write((uint64_t*)&forMarshaling->producer, sizeof(uint64_t));
+    vkStream->write((VkBool32*)&forMarshaling->sharedImage, sizeof(VkBool32));
 }
 
-void unmarshal_VkNativeBufferANDROID(VulkanStream* vkStream, VkStructureType rootType,
-                                     VkNativeBufferANDROID* forUnmarshaling) {
+void unmarshal_VkPhysicalDevicePresentationPropertiesANDROID(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePresentationPropertiesANDROID* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -17433,17 +19866,7 @@ void unmarshal_VkNativeBufferANDROID(VulkanStream* vkStream, VkStructureType roo
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    // WARNING PTR CHECK
-    forUnmarshaling->handle = (const uint32_t*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->handle) {
-        vkStream->alloc((void**)&forUnmarshaling->handle, sizeof(const uint32_t));
-        vkStream->read((uint32_t*)forUnmarshaling->handle, sizeof(const uint32_t));
-    }
-    vkStream->read((int*)&forUnmarshaling->stride, sizeof(int));
-    vkStream->read((int*)&forUnmarshaling->format, sizeof(int));
-    vkStream->read((int*)&forUnmarshaling->usage, sizeof(int));
-    vkStream->read((uint64_t*)&forUnmarshaling->consumer, sizeof(uint64_t));
-    vkStream->read((uint64_t*)&forUnmarshaling->producer, sizeof(uint64_t));
+    vkStream->read((VkBool32*)&forUnmarshaling->sharedImage, sizeof(VkBool32));
 }
 
 #endif
@@ -18188,19 +20611,15 @@ void marshal_VkVideoEncodeH264CapabilitiesEXT(
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
     vkStream->write((VkVideoEncodeH264CapabilityFlagsEXT*)&forMarshaling->flags,
                     sizeof(VkVideoEncodeH264CapabilityFlagsEXT));
-    vkStream->write((VkVideoEncodeH264InputModeFlagsEXT*)&forMarshaling->inputModeFlags,
-                    sizeof(VkVideoEncodeH264InputModeFlagsEXT));
-    vkStream->write((VkVideoEncodeH264OutputModeFlagsEXT*)&forMarshaling->outputModeFlags,
-                    sizeof(VkVideoEncodeH264OutputModeFlagsEXT));
-    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minPictureSizeInMbs));
-    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxPictureSizeInMbs));
-    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->inputImageDataAlignment));
-    vkStream->write((uint8_t*)&forMarshaling->maxNumL0ReferenceForP, sizeof(uint8_t));
-    vkStream->write((uint8_t*)&forMarshaling->maxNumL0ReferenceForB, sizeof(uint8_t));
-    vkStream->write((uint8_t*)&forMarshaling->maxNumL1Reference, sizeof(uint8_t));
-    vkStream->write((uint8_t*)&forMarshaling->qualityLevelCount, sizeof(uint8_t));
-    marshal_VkExtensionProperties(vkStream, rootType,
-                                  (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion));
+    vkStream->write((uint32_t*)&forMarshaling->maxPPictureL0ReferenceCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxBPictureL0ReferenceCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxL1ReferenceCount, sizeof(uint32_t));
+    vkStream->write((VkBool32*)&forMarshaling->motionVectorsOverPicBoundariesFlag,
+                    sizeof(VkBool32));
+    vkStream->write((uint32_t*)&forMarshaling->maxBytesPerPicDenom, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxBitsPerMbDenom, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->log2MaxMvLengthHorizontal, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->log2MaxMvLengthVertical, sizeof(uint32_t));
 }
 
 void unmarshal_VkVideoEncodeH264CapabilitiesEXT(VulkanStream* vkStream, VkStructureType rootType,
@@ -18225,66 +20644,15 @@ void unmarshal_VkVideoEncodeH264CapabilitiesEXT(VulkanStream* vkStream, VkStruct
     }
     vkStream->read((VkVideoEncodeH264CapabilityFlagsEXT*)&forUnmarshaling->flags,
                    sizeof(VkVideoEncodeH264CapabilityFlagsEXT));
-    vkStream->read((VkVideoEncodeH264InputModeFlagsEXT*)&forUnmarshaling->inputModeFlags,
-                   sizeof(VkVideoEncodeH264InputModeFlagsEXT));
-    vkStream->read((VkVideoEncodeH264OutputModeFlagsEXT*)&forUnmarshaling->outputModeFlags,
-                   sizeof(VkVideoEncodeH264OutputModeFlagsEXT));
-    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minPictureSizeInMbs));
-    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxPictureSizeInMbs));
-    unmarshal_VkExtent2D(vkStream, rootType,
-                         (VkExtent2D*)(&forUnmarshaling->inputImageDataAlignment));
-    vkStream->read((uint8_t*)&forUnmarshaling->maxNumL0ReferenceForP, sizeof(uint8_t));
-    vkStream->read((uint8_t*)&forUnmarshaling->maxNumL0ReferenceForB, sizeof(uint8_t));
-    vkStream->read((uint8_t*)&forUnmarshaling->maxNumL1Reference, sizeof(uint8_t));
-    vkStream->read((uint8_t*)&forUnmarshaling->qualityLevelCount, sizeof(uint8_t));
-    unmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion));
-}
-
-void marshal_VkVideoEncodeH264SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoEncodeH264SessionCreateInfoEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkVideoEncodeH264CreateFlagsEXT*)&forMarshaling->flags,
-                    sizeof(VkVideoEncodeH264CreateFlagsEXT));
-    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxPictureSizeInMbs));
-    marshal_VkExtensionProperties(
-        vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion));
-}
-
-void unmarshal_VkVideoEncodeH264SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH264SessionCreateInfoEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkVideoEncodeH264CreateFlagsEXT*)&forUnmarshaling->flags,
-                   sizeof(VkVideoEncodeH264CreateFlagsEXT));
-    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxPictureSizeInMbs));
-    vkStream->alloc((void**)&forUnmarshaling->pStdExtensionVersion,
-                    sizeof(const VkExtensionProperties));
-    unmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPPictureL0ReferenceCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxBPictureL0ReferenceCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxL1ReferenceCount, sizeof(uint32_t));
+    vkStream->read((VkBool32*)&forUnmarshaling->motionVectorsOverPicBoundariesFlag,
+                   sizeof(VkBool32));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxBytesPerPicDenom, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxBitsPerMbDenom, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->log2MaxMvLengthHorizontal, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->log2MaxMvLengthVertical, sizeof(uint32_t));
 }
 
 void marshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
@@ -18296,22 +20664,22 @@ void marshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->spsStdCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->stdSPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pSpsStd;
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pStdSPSs;
     vkStream->putBe64(cgen_var_0);
-    if (forMarshaling->pSpsStd) {
+    if (forMarshaling->pStdSPSs) {
         vkStream->write(
-            (const StdVideoH264SequenceParameterSet*)forMarshaling->pSpsStd,
-            forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
+            (const StdVideoH264SequenceParameterSet*)forMarshaling->pStdSPSs,
+            forMarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
     }
-    vkStream->write((uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->stdPPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pPpsStd;
+    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pStdPPSs;
     vkStream->putBe64(cgen_var_1);
-    if (forMarshaling->pPpsStd) {
-        vkStream->write((const StdVideoH264PictureParameterSet*)forMarshaling->pPpsStd,
-                        forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
+    if (forMarshaling->pStdPPSs) {
+        vkStream->write((const StdVideoH264PictureParameterSet*)forMarshaling->pStdPPSs,
+                        forMarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
     }
 }
 
@@ -18336,29 +20704,29 @@ void unmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((uint32_t*)&forUnmarshaling->spsStdCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->stdSPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    forUnmarshaling->pSpsStd =
+    forUnmarshaling->pStdSPSs =
         (const StdVideoH264SequenceParameterSet*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pSpsStd) {
+    if (forUnmarshaling->pStdSPSs) {
         vkStream->alloc(
-            (void**)&forUnmarshaling->pSpsStd,
-            forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
+            (void**)&forUnmarshaling->pStdSPSs,
+            forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
         vkStream->read(
-            (StdVideoH264SequenceParameterSet*)forUnmarshaling->pSpsStd,
-            forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
+            (StdVideoH264SequenceParameterSet*)forUnmarshaling->pStdSPSs,
+            forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
     }
-    vkStream->read((uint32_t*)&forUnmarshaling->ppsStdCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->stdPPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    forUnmarshaling->pPpsStd =
+    forUnmarshaling->pStdPPSs =
         (const StdVideoH264PictureParameterSet*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pPpsStd) {
+    if (forUnmarshaling->pStdPPSs) {
         vkStream->alloc(
-            (void**)&forUnmarshaling->pPpsStd,
-            forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
+            (void**)&forUnmarshaling->pStdPPSs,
+            forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
         vkStream->read(
-            (StdVideoH264PictureParameterSet*)forUnmarshaling->pPpsStd,
-            forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
+            (StdVideoH264PictureParameterSet*)forUnmarshaling->pStdPPSs,
+            forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
     }
 }
 
@@ -18371,8 +20739,8 @@ void marshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->maxSpsStdCount, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->maxPpsStdCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxStdSPSCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxStdPPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
     uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
     vkStream->putBe64(cgen_var_0);
@@ -18405,8 +20773,8 @@ void unmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((uint32_t*)&forUnmarshaling->maxSpsStdCount, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxPpsStdCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxStdSPSCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxStdPPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
     forUnmarshaling->pParametersAddInfo =
         (const VkVideoEncodeH264SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
@@ -18419,21 +20787,31 @@ void unmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     }
 }
 
-void marshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling) {
+void marshal_VkVideoEncodeH264NaluSliceInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoEncodeH264NaluSliceInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((int8_t*)&forMarshaling->slotIndex, sizeof(int8_t));
-    vkStream->write((const StdVideoEncodeH264PictureInfo*)forMarshaling->pStdPictureInfo,
-                    sizeof(const StdVideoEncodeH264PictureInfo));
+    vkStream->write((uint32_t*)&forMarshaling->mbCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pStdReferenceFinalLists;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pStdReferenceFinalLists) {
+        vkStream->write(
+            (const StdVideoEncodeH264ReferenceListsInfo*)forMarshaling->pStdReferenceFinalLists,
+            sizeof(const StdVideoEncodeH264ReferenceListsInfo));
+    }
+    vkStream->write((const StdVideoEncodeH264SliceHeader*)forMarshaling->pStdSliceHeader,
+                    sizeof(const StdVideoEncodeH264SliceHeader));
 }
 
-void unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoEncodeH264DpbSlotInfoEXT* forUnmarshaling) {
+void unmarshal_VkVideoEncodeH264NaluSliceInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH264NaluSliceInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -18452,47 +20830,54 @@ void unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructu
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((int8_t*)&forUnmarshaling->slotIndex, sizeof(int8_t));
-    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
-                    sizeof(const StdVideoEncodeH264PictureInfo));
-    vkStream->read((StdVideoEncodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo,
-                   sizeof(const StdVideoEncodeH264PictureInfo));
+    vkStream->read((uint32_t*)&forUnmarshaling->mbCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pStdReferenceFinalLists =
+        (const StdVideoEncodeH264ReferenceListsInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pStdReferenceFinalLists) {
+        vkStream->alloc((void**)&forUnmarshaling->pStdReferenceFinalLists,
+                        sizeof(const StdVideoEncodeH264ReferenceListsInfo));
+        vkStream->read(
+            (StdVideoEncodeH264ReferenceListsInfo*)forUnmarshaling->pStdReferenceFinalLists,
+            sizeof(const StdVideoEncodeH264ReferenceListsInfo));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pStdSliceHeader,
+                    sizeof(const StdVideoEncodeH264SliceHeader));
+    vkStream->read((StdVideoEncodeH264SliceHeader*)forUnmarshaling->pStdSliceHeader,
+                   sizeof(const StdVideoEncodeH264SliceHeader));
 }
 
-void marshal_VkVideoEncodeH264NaluSliceEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           const VkVideoEncodeH264NaluSliceEXT* forMarshaling) {
+void marshal_VkVideoEncodeH264VclFrameInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoEncodeH264VclFrameInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((const StdVideoEncodeH264SliceHeader*)forMarshaling->pSliceHeaderStd,
-                    sizeof(const StdVideoEncodeH264SliceHeader));
-    vkStream->write((uint32_t*)&forMarshaling->mbCount, sizeof(uint32_t));
-    vkStream->write((uint8_t*)&forMarshaling->refFinalList0EntryCount, sizeof(uint8_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->refFinalList0EntryCount; ++i) {
-            marshal_VkVideoEncodeH264DpbSlotInfoEXT(
-                vkStream, rootType,
-                (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefFinalList0Entries + i));
-        }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pStdReferenceFinalLists;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pStdReferenceFinalLists) {
+        vkStream->write(
+            (const StdVideoEncodeH264ReferenceListsInfo*)forMarshaling->pStdReferenceFinalLists,
+            sizeof(const StdVideoEncodeH264ReferenceListsInfo));
     }
-    vkStream->write((uint8_t*)&forMarshaling->refFinalList1EntryCount, sizeof(uint8_t));
+    vkStream->write((uint32_t*)&forMarshaling->naluSliceEntryCount, sizeof(uint32_t));
     if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->refFinalList1EntryCount; ++i) {
-            marshal_VkVideoEncodeH264DpbSlotInfoEXT(
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i) {
+            marshal_VkVideoEncodeH264NaluSliceInfoEXT(
                 vkStream, rootType,
-                (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pRefFinalList1Entries + i));
+                (const VkVideoEncodeH264NaluSliceInfoEXT*)(forMarshaling->pNaluSliceEntries + i));
         }
     }
-    vkStream->write((uint32_t*)&forMarshaling->precedingNaluBytes, sizeof(uint32_t));
-    vkStream->write((uint8_t*)&forMarshaling->minQp, sizeof(uint8_t));
-    vkStream->write((uint8_t*)&forMarshaling->maxQp, sizeof(uint8_t));
+    vkStream->write((const StdVideoEncodeH264PictureInfo*)forMarshaling->pStdPictureInfo,
+                    sizeof(const StdVideoEncodeH264PictureInfo));
 }
 
-void unmarshal_VkVideoEncodeH264NaluSliceEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             VkVideoEncodeH264NaluSliceEXT* forUnmarshaling) {
+void unmarshal_VkVideoEncodeH264VclFrameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkVideoEncodeH264VclFrameInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -18511,82 +20896,47 @@ void unmarshal_VkVideoEncodeH264NaluSliceEXT(VulkanStream* vkStream, VkStructure
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->alloc((void**)&forUnmarshaling->pSliceHeaderStd,
-                    sizeof(const StdVideoEncodeH264SliceHeader));
-    vkStream->read((StdVideoEncodeH264SliceHeader*)forUnmarshaling->pSliceHeaderStd,
-                   sizeof(const StdVideoEncodeH264SliceHeader));
-    vkStream->read((uint32_t*)&forUnmarshaling->mbCount, sizeof(uint32_t));
-    vkStream->read((uint8_t*)&forUnmarshaling->refFinalList0EntryCount, sizeof(uint8_t));
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pRefFinalList0Entries,
-        forUnmarshaling->refFinalList0EntryCount * sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refFinalList0EntryCount; ++i) {
-            unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
-                vkStream, rootType,
-                (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefFinalList0Entries + i));
-        }
+    // WARNING PTR CHECK
+    forUnmarshaling->pStdReferenceFinalLists =
+        (const StdVideoEncodeH264ReferenceListsInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pStdReferenceFinalLists) {
+        vkStream->alloc((void**)&forUnmarshaling->pStdReferenceFinalLists,
+                        sizeof(const StdVideoEncodeH264ReferenceListsInfo));
+        vkStream->read(
+            (StdVideoEncodeH264ReferenceListsInfo*)forUnmarshaling->pStdReferenceFinalLists,
+            sizeof(const StdVideoEncodeH264ReferenceListsInfo));
     }
-    vkStream->read((uint8_t*)&forUnmarshaling->refFinalList1EntryCount, sizeof(uint8_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->naluSliceEntryCount, sizeof(uint32_t));
     vkStream->alloc(
-        (void**)&forUnmarshaling->pRefFinalList1Entries,
-        forUnmarshaling->refFinalList1EntryCount * sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
+        (void**)&forUnmarshaling->pNaluSliceEntries,
+        forUnmarshaling->naluSliceEntryCount * sizeof(const VkVideoEncodeH264NaluSliceInfoEXT));
     if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refFinalList1EntryCount; ++i) {
-            unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceEntryCount; ++i) {
+            unmarshal_VkVideoEncodeH264NaluSliceInfoEXT(
                 vkStream, rootType,
-                (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefFinalList1Entries + i));
+                (VkVideoEncodeH264NaluSliceInfoEXT*)(forUnmarshaling->pNaluSliceEntries + i));
         }
     }
-    vkStream->read((uint32_t*)&forUnmarshaling->precedingNaluBytes, sizeof(uint32_t));
-    vkStream->read((uint8_t*)&forUnmarshaling->minQp, sizeof(uint8_t));
-    vkStream->read((uint8_t*)&forUnmarshaling->maxQp, sizeof(uint8_t));
+    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
+                    sizeof(const StdVideoEncodeH264PictureInfo));
+    vkStream->read((StdVideoEncodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo,
+                   sizeof(const StdVideoEncodeH264PictureInfo));
 }
 
-void marshal_VkVideoEncodeH264VclFrameInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoEncodeH264VclFrameInfoEXT* forMarshaling) {
+void marshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint8_t*)&forMarshaling->refDefaultFinalList0EntryCount, sizeof(uint8_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->refDefaultFinalList0EntryCount; ++i) {
-            marshal_VkVideoEncodeH264DpbSlotInfoEXT(
-                vkStream, rootType,
-                (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling
-                                                             ->pRefDefaultFinalList0Entries +
-                                                         i));
-        }
-    }
-    vkStream->write((uint8_t*)&forMarshaling->refDefaultFinalList1EntryCount, sizeof(uint8_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->refDefaultFinalList1EntryCount; ++i) {
-            marshal_VkVideoEncodeH264DpbSlotInfoEXT(
-                vkStream, rootType,
-                (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling
-                                                             ->pRefDefaultFinalList1Entries +
-                                                         i));
-        }
-    }
-    vkStream->write((uint32_t*)&forMarshaling->naluSliceEntryCount, sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i) {
-            marshal_VkVideoEncodeH264NaluSliceEXT(
-                vkStream, rootType,
-                (const VkVideoEncodeH264NaluSliceEXT*)(forMarshaling->pNaluSliceEntries + i));
-        }
-    }
-    marshal_VkVideoEncodeH264DpbSlotInfoEXT(
-        vkStream, rootType,
-        (const VkVideoEncodeH264DpbSlotInfoEXT*)(forMarshaling->pCurrentPictureInfo));
+    vkStream->write((const StdVideoEncodeH264ReferenceInfo*)forMarshaling->pStdReferenceInfo,
+                    sizeof(const StdVideoEncodeH264ReferenceInfo));
 }
 
-void unmarshal_VkVideoEncodeH264VclFrameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkVideoEncodeH264VclFrameInfoEXT* forUnmarshaling) {
+void unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoEncodeH264DpbSlotInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -18605,67 +20955,26 @@ void unmarshal_VkVideoEncodeH264VclFrameInfoEXT(VulkanStream* vkStream, VkStruct
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((uint8_t*)&forUnmarshaling->refDefaultFinalList0EntryCount, sizeof(uint8_t));
-    vkStream->alloc((void**)&forUnmarshaling->pRefDefaultFinalList0Entries,
-                    forUnmarshaling->refDefaultFinalList0EntryCount *
-                        sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refDefaultFinalList0EntryCount; ++i) {
-            unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
-                vkStream, rootType,
-                (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefDefaultFinalList0Entries +
-                                                   i));
-        }
-    }
-    vkStream->read((uint8_t*)&forUnmarshaling->refDefaultFinalList1EntryCount, sizeof(uint8_t));
-    vkStream->alloc((void**)&forUnmarshaling->pRefDefaultFinalList1Entries,
-                    forUnmarshaling->refDefaultFinalList1EntryCount *
-                        sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refDefaultFinalList1EntryCount; ++i) {
-            unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
-                vkStream, rootType,
-                (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefDefaultFinalList1Entries +
-                                                   i));
-        }
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->naluSliceEntryCount, sizeof(uint32_t));
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pNaluSliceEntries,
-        forUnmarshaling->naluSliceEntryCount * sizeof(const VkVideoEncodeH264NaluSliceEXT));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceEntryCount; ++i) {
-            unmarshal_VkVideoEncodeH264NaluSliceEXT(
-                vkStream, rootType,
-                (VkVideoEncodeH264NaluSliceEXT*)(forUnmarshaling->pNaluSliceEntries + i));
-        }
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pCurrentPictureInfo,
-                    sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-    unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
-        vkStream, rootType,
-        (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pCurrentPictureInfo));
+    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
+                    sizeof(const StdVideoEncodeH264ReferenceInfo));
+    vkStream->read((StdVideoEncodeH264ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
+                   sizeof(const StdVideoEncodeH264ReferenceInfo));
 }
 
-void marshal_VkVideoEncodeH264EmitPictureParametersEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoEncodeH264EmitPictureParametersEXT* forMarshaling) {
+void marshal_VkVideoEncodeH264ProfileInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoEncodeH264ProfileInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint8_t*)&forMarshaling->spsId, sizeof(uint8_t));
-    vkStream->write((VkBool32*)&forMarshaling->emitSpsEnable, sizeof(VkBool32));
-    vkStream->write((uint32_t*)&forMarshaling->ppsIdEntryCount, sizeof(uint32_t));
-    vkStream->write((const uint8_t*)forMarshaling->ppsIdEntries,
-                    forMarshaling->ppsIdEntryCount * sizeof(const uint8_t));
+    vkStream->write((StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc,
+                    sizeof(StdVideoH264ProfileIdc));
 }
 
-void unmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH264EmitPictureParametersEXT* forUnmarshaling) {
+void unmarshal_VkVideoEncodeH264ProfileInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoEncodeH264ProfileInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -18684,29 +20993,30 @@ void unmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((uint8_t*)&forUnmarshaling->spsId, sizeof(uint8_t));
-    vkStream->read((VkBool32*)&forUnmarshaling->emitSpsEnable, sizeof(VkBool32));
-    vkStream->read((uint32_t*)&forUnmarshaling->ppsIdEntryCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->ppsIdEntries,
-                    forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t));
-    vkStream->read((uint8_t*)forUnmarshaling->ppsIdEntries,
-                   forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t));
+    vkStream->read((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc,
+                   sizeof(StdVideoH264ProfileIdc));
 }
 
-void marshal_VkVideoEncodeH264ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                         const VkVideoEncodeH264ProfileEXT* forMarshaling) {
+void marshal_VkVideoEncodeH264RateControlInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoEncodeH264RateControlInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc,
-                    sizeof(StdVideoH264ProfileIdc));
+    vkStream->write((uint32_t*)&forMarshaling->gopFrameCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->idrPeriod, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->consecutiveBFrameCount, sizeof(uint32_t));
+    vkStream->write((VkVideoEncodeH264RateControlStructureEXT*)&forMarshaling->rateControlStructure,
+                    sizeof(VkVideoEncodeH264RateControlStructureEXT));
+    vkStream->write((uint32_t*)&forMarshaling->temporalLayerCount, sizeof(uint32_t));
 }
 
-void unmarshal_VkVideoEncodeH264ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkVideoEncodeH264ProfileEXT* forUnmarshaling) {
+void unmarshal_VkVideoEncodeH264RateControlInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH264RateControlInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -18725,41 +21035,74 @@ void unmarshal_VkVideoEncodeH264ProfileEXT(VulkanStream* vkStream, VkStructureTy
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc,
-                   sizeof(StdVideoH264ProfileIdc));
+    vkStream->read((uint32_t*)&forUnmarshaling->gopFrameCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->idrPeriod, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->consecutiveBFrameCount, sizeof(uint32_t));
+    vkStream->read(
+        (VkVideoEncodeH264RateControlStructureEXT*)&forUnmarshaling->rateControlStructure,
+        sizeof(VkVideoEncodeH264RateControlStructureEXT));
+    vkStream->read((uint32_t*)&forUnmarshaling->temporalLayerCount, sizeof(uint32_t));
 }
 
-#endif
-#ifdef VK_EXT_video_encode_h265
-void marshal_VkVideoEncodeH265CapabilitiesEXT(
+void marshal_VkVideoEncodeH264QpEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkVideoEncodeH264QpEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((int32_t*)&forMarshaling->qpI, sizeof(int32_t));
+    vkStream->write((int32_t*)&forMarshaling->qpP, sizeof(int32_t));
+    vkStream->write((int32_t*)&forMarshaling->qpB, sizeof(int32_t));
+}
+
+void unmarshal_VkVideoEncodeH264QpEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkVideoEncodeH264QpEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((int32_t*)&forUnmarshaling->qpI, sizeof(int32_t));
+    vkStream->read((int32_t*)&forUnmarshaling->qpP, sizeof(int32_t));
+    vkStream->read((int32_t*)&forUnmarshaling->qpB, sizeof(int32_t));
+}
+
+void marshal_VkVideoEncodeH264FrameSizeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkVideoEncodeH264FrameSizeEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((uint32_t*)&forMarshaling->frameISize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->framePSize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->frameBSize, sizeof(uint32_t));
+}
+
+void unmarshal_VkVideoEncodeH264FrameSizeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkVideoEncodeH264FrameSizeEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((uint32_t*)&forUnmarshaling->frameISize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->framePSize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->frameBSize, sizeof(uint32_t));
+}
+
+void marshal_VkVideoEncodeH264RateControlLayerInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoEncodeH265CapabilitiesEXT* forMarshaling) {
+    const VkVideoEncodeH264RateControlLayerInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkVideoEncodeH265CapabilityFlagsEXT*)&forMarshaling->flags,
-                    sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
-    vkStream->write((VkVideoEncodeH265InputModeFlagsEXT*)&forMarshaling->inputModeFlags,
-                    sizeof(VkVideoEncodeH265InputModeFlagsEXT));
-    vkStream->write((VkVideoEncodeH265OutputModeFlagsEXT*)&forMarshaling->outputModeFlags,
-                    sizeof(VkVideoEncodeH265OutputModeFlagsEXT));
-    vkStream->write((VkVideoEncodeH265CtbSizeFlagsEXT*)&forMarshaling->ctbSizes,
-                    sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
-    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->inputImageDataAlignment));
-    vkStream->write((uint8_t*)&forMarshaling->maxNumL0ReferenceForP, sizeof(uint8_t));
-    vkStream->write((uint8_t*)&forMarshaling->maxNumL0ReferenceForB, sizeof(uint8_t));
-    vkStream->write((uint8_t*)&forMarshaling->maxNumL1Reference, sizeof(uint8_t));
-    vkStream->write((uint8_t*)&forMarshaling->maxNumSubLayers, sizeof(uint8_t));
-    vkStream->write((uint8_t*)&forMarshaling->qualityLevelCount, sizeof(uint8_t));
-    marshal_VkExtensionProperties(vkStream, rootType,
-                                  (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion));
+    vkStream->write((uint32_t*)&forMarshaling->temporalLayerId, sizeof(uint32_t));
+    vkStream->write((VkBool32*)&forMarshaling->useInitialRcQp, sizeof(VkBool32));
+    marshal_VkVideoEncodeH264QpEXT(vkStream, rootType,
+                                   (VkVideoEncodeH264QpEXT*)(&forMarshaling->initialRcQp));
+    vkStream->write((VkBool32*)&forMarshaling->useMinQp, sizeof(VkBool32));
+    marshal_VkVideoEncodeH264QpEXT(vkStream, rootType,
+                                   (VkVideoEncodeH264QpEXT*)(&forMarshaling->minQp));
+    vkStream->write((VkBool32*)&forMarshaling->useMaxQp, sizeof(VkBool32));
+    marshal_VkVideoEncodeH264QpEXT(vkStream, rootType,
+                                   (VkVideoEncodeH264QpEXT*)(&forMarshaling->maxQp));
+    vkStream->write((VkBool32*)&forMarshaling->useMaxFrameSize, sizeof(VkBool32));
+    marshal_VkVideoEncodeH264FrameSizeEXT(
+        vkStream, rootType, (VkVideoEncodeH264FrameSizeEXT*)(&forMarshaling->maxFrameSize));
 }
 
-void unmarshal_VkVideoEncodeH265CapabilitiesEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkVideoEncodeH265CapabilitiesEXT* forUnmarshaling) {
+void unmarshal_VkVideoEncodeH264RateControlLayerInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH264RateControlLayerInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -18778,43 +21121,66 @@ void unmarshal_VkVideoEncodeH265CapabilitiesEXT(VulkanStream* vkStream, VkStruct
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkVideoEncodeH265CapabilityFlagsEXT*)&forUnmarshaling->flags,
-                   sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
-    vkStream->read((VkVideoEncodeH265InputModeFlagsEXT*)&forUnmarshaling->inputModeFlags,
-                   sizeof(VkVideoEncodeH265InputModeFlagsEXT));
-    vkStream->read((VkVideoEncodeH265OutputModeFlagsEXT*)&forUnmarshaling->outputModeFlags,
-                   sizeof(VkVideoEncodeH265OutputModeFlagsEXT));
-    vkStream->read((VkVideoEncodeH265CtbSizeFlagsEXT*)&forUnmarshaling->ctbSizes,
-                   sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
-    unmarshal_VkExtent2D(vkStream, rootType,
-                         (VkExtent2D*)(&forUnmarshaling->inputImageDataAlignment));
-    vkStream->read((uint8_t*)&forUnmarshaling->maxNumL0ReferenceForP, sizeof(uint8_t));
-    vkStream->read((uint8_t*)&forUnmarshaling->maxNumL0ReferenceForB, sizeof(uint8_t));
-    vkStream->read((uint8_t*)&forUnmarshaling->maxNumL1Reference, sizeof(uint8_t));
-    vkStream->read((uint8_t*)&forUnmarshaling->maxNumSubLayers, sizeof(uint8_t));
-    vkStream->read((uint8_t*)&forUnmarshaling->qualityLevelCount, sizeof(uint8_t));
-    unmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion));
+    vkStream->read((uint32_t*)&forUnmarshaling->temporalLayerId, sizeof(uint32_t));
+    vkStream->read((VkBool32*)&forUnmarshaling->useInitialRcQp, sizeof(VkBool32));
+    unmarshal_VkVideoEncodeH264QpEXT(vkStream, rootType,
+                                     (VkVideoEncodeH264QpEXT*)(&forUnmarshaling->initialRcQp));
+    vkStream->read((VkBool32*)&forUnmarshaling->useMinQp, sizeof(VkBool32));
+    unmarshal_VkVideoEncodeH264QpEXT(vkStream, rootType,
+                                     (VkVideoEncodeH264QpEXT*)(&forUnmarshaling->minQp));
+    vkStream->read((VkBool32*)&forUnmarshaling->useMaxQp, sizeof(VkBool32));
+    unmarshal_VkVideoEncodeH264QpEXT(vkStream, rootType,
+                                     (VkVideoEncodeH264QpEXT*)(&forUnmarshaling->maxQp));
+    vkStream->read((VkBool32*)&forUnmarshaling->useMaxFrameSize, sizeof(VkBool32));
+    unmarshal_VkVideoEncodeH264FrameSizeEXT(
+        vkStream, rootType, (VkVideoEncodeH264FrameSizeEXT*)(&forUnmarshaling->maxFrameSize));
 }
 
-void marshal_VkVideoEncodeH265SessionCreateInfoEXT(
+#endif
+#ifdef VK_EXT_video_encode_h265
+void marshal_VkVideoEncodeH265CapabilitiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoEncodeH265SessionCreateInfoEXT* forMarshaling) {
+    const VkVideoEncodeH265CapabilitiesEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkVideoEncodeH265CreateFlagsEXT*)&forMarshaling->flags,
-                    sizeof(VkVideoEncodeH265CreateFlagsEXT));
-    marshal_VkExtensionProperties(
-        vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion));
+    vkStream->write((VkVideoEncodeH265CapabilityFlagsEXT*)&forMarshaling->flags,
+                    sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
+    vkStream->write((VkVideoEncodeH265CtbSizeFlagsEXT*)&forMarshaling->ctbSizes,
+                    sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
+    vkStream->write(
+        (VkVideoEncodeH265TransformBlockSizeFlagsEXT*)&forMarshaling->transformBlockSizes,
+        sizeof(VkVideoEncodeH265TransformBlockSizeFlagsEXT));
+    vkStream->write((uint32_t*)&forMarshaling->maxPPictureL0ReferenceCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxBPictureL0ReferenceCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxL1ReferenceCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxSubLayersCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->minLog2MinLumaCodingBlockSizeMinus3,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxLog2MinLumaCodingBlockSizeMinus3,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->minLog2MinLumaTransformBlockSizeMinus2,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxLog2MinLumaTransformBlockSizeMinus2,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->minMaxTransformHierarchyDepthInter,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMaxTransformHierarchyDepthInter,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->minMaxTransformHierarchyDepthIntra,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMaxTransformHierarchyDepthIntra,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxDiffCuQpDeltaDepth, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->minMaxNumMergeCand, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMaxNumMergeCand, sizeof(uint32_t));
 }
 
-void unmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265SessionCreateInfoEXT* forUnmarshaling) {
+void unmarshal_VkVideoEncodeH265CapabilitiesEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkVideoEncodeH265CapabilitiesEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -18833,12 +21199,36 @@ void unmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkVideoEncodeH265CreateFlagsEXT*)&forUnmarshaling->flags,
-                   sizeof(VkVideoEncodeH265CreateFlagsEXT));
-    vkStream->alloc((void**)&forUnmarshaling->pStdExtensionVersion,
-                    sizeof(const VkExtensionProperties));
-    unmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion));
+    vkStream->read((VkVideoEncodeH265CapabilityFlagsEXT*)&forUnmarshaling->flags,
+                   sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
+    vkStream->read((VkVideoEncodeH265CtbSizeFlagsEXT*)&forUnmarshaling->ctbSizes,
+                   sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
+    vkStream->read(
+        (VkVideoEncodeH265TransformBlockSizeFlagsEXT*)&forUnmarshaling->transformBlockSizes,
+        sizeof(VkVideoEncodeH265TransformBlockSizeFlagsEXT));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPPictureL0ReferenceCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxBPictureL0ReferenceCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxL1ReferenceCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxSubLayersCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->minLog2MinLumaCodingBlockSizeMinus3,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxLog2MinLumaCodingBlockSizeMinus3,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->minLog2MinLumaTransformBlockSizeMinus2,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxLog2MinLumaTransformBlockSizeMinus2,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->minMaxTransformHierarchyDepthInter,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMaxTransformHierarchyDepthInter,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->minMaxTransformHierarchyDepthIntra,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMaxTransformHierarchyDepthIntra,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDiffCuQpDeltaDepth, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->minMaxNumMergeCand, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMaxNumMergeCand, sizeof(uint32_t));
 }
 
 void marshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
@@ -18850,30 +21240,30 @@ void marshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->vpsStdCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->stdVPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pVpsStd;
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pStdVPSs;
     vkStream->putBe64(cgen_var_0);
-    if (forMarshaling->pVpsStd) {
-        vkStream->write((const StdVideoH265VideoParameterSet*)forMarshaling->pVpsStd,
-                        forMarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
+    if (forMarshaling->pStdVPSs) {
+        vkStream->write((const StdVideoH265VideoParameterSet*)forMarshaling->pStdVPSs,
+                        forMarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
     }
-    vkStream->write((uint32_t*)&forMarshaling->spsStdCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->stdSPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSpsStd;
+    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pStdSPSs;
     vkStream->putBe64(cgen_var_1);
-    if (forMarshaling->pSpsStd) {
+    if (forMarshaling->pStdSPSs) {
         vkStream->write(
-            (const StdVideoH265SequenceParameterSet*)forMarshaling->pSpsStd,
-            forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
+            (const StdVideoH265SequenceParameterSet*)forMarshaling->pStdSPSs,
+            forMarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
     }
-    vkStream->write((uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->stdPPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pPpsStd;
+    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pStdPPSs;
     vkStream->putBe64(cgen_var_2);
-    if (forMarshaling->pPpsStd) {
-        vkStream->write((const StdVideoH265PictureParameterSet*)forMarshaling->pPpsStd,
-                        forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
+    if (forMarshaling->pStdPPSs) {
+        vkStream->write((const StdVideoH265PictureParameterSet*)forMarshaling->pStdPPSs,
+                        forMarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
     }
 }
 
@@ -18898,38 +21288,39 @@ void unmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((uint32_t*)&forUnmarshaling->vpsStdCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->stdVPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    forUnmarshaling->pVpsStd = (const StdVideoH265VideoParameterSet*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pVpsStd) {
-        vkStream->alloc((void**)&forUnmarshaling->pVpsStd,
-                        forUnmarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
-        vkStream->read((StdVideoH265VideoParameterSet*)forUnmarshaling->pVpsStd,
-                       forUnmarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->spsStdCount, sizeof(uint32_t));
+    forUnmarshaling->pStdVPSs =
+        (const StdVideoH265VideoParameterSet*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pStdVPSs) {
+        vkStream->alloc((void**)&forUnmarshaling->pStdVPSs,
+                        forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
+        vkStream->read((StdVideoH265VideoParameterSet*)forUnmarshaling->pStdVPSs,
+                       forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->stdSPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    forUnmarshaling->pSpsStd =
+    forUnmarshaling->pStdSPSs =
         (const StdVideoH265SequenceParameterSet*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pSpsStd) {
+    if (forUnmarshaling->pStdSPSs) {
         vkStream->alloc(
-            (void**)&forUnmarshaling->pSpsStd,
-            forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
+            (void**)&forUnmarshaling->pStdSPSs,
+            forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
         vkStream->read(
-            (StdVideoH265SequenceParameterSet*)forUnmarshaling->pSpsStd,
-            forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
+            (StdVideoH265SequenceParameterSet*)forUnmarshaling->pStdSPSs,
+            forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
     }
-    vkStream->read((uint32_t*)&forUnmarshaling->ppsStdCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->stdPPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    forUnmarshaling->pPpsStd =
+    forUnmarshaling->pStdPPSs =
         (const StdVideoH265PictureParameterSet*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pPpsStd) {
+    if (forUnmarshaling->pStdPPSs) {
         vkStream->alloc(
-            (void**)&forUnmarshaling->pPpsStd,
-            forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
+            (void**)&forUnmarshaling->pStdPPSs,
+            forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
         vkStream->read(
-            (StdVideoH265PictureParameterSet*)forUnmarshaling->pPpsStd,
-            forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
+            (StdVideoH265PictureParameterSet*)forUnmarshaling->pStdPPSs,
+            forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
     }
 }
 
@@ -18942,9 +21333,9 @@ void marshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->maxVpsStdCount, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->maxSpsStdCount, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->maxPpsStdCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxStdVPSCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxStdSPSCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxStdPPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
     uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
     vkStream->putBe64(cgen_var_0);
@@ -18977,9 +21368,9 @@ void unmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((uint32_t*)&forUnmarshaling->maxVpsStdCount, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxSpsStdCount, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxPpsStdCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxStdVPSCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxStdSPSCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxStdPPSCount, sizeof(uint32_t));
     // WARNING PTR CHECK
     forUnmarshaling->pParametersAddInfo =
         (const VkVideoEncodeH265SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
@@ -18992,130 +21383,9 @@ void unmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
     }
 }
 
-void marshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((int8_t*)&forMarshaling->slotIndex, sizeof(int8_t));
-    vkStream->write((const StdVideoEncodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo,
-                    sizeof(const StdVideoEncodeH265ReferenceInfo));
-}
-
-void unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoEncodeH265DpbSlotInfoEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((int8_t*)&forUnmarshaling->slotIndex, sizeof(int8_t));
-    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
-                    sizeof(const StdVideoEncodeH265ReferenceInfo));
-    vkStream->read((StdVideoEncodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
-                   sizeof(const StdVideoEncodeH265ReferenceInfo));
-}
-
-void marshal_VkVideoEncodeH265ReferenceListsEXT(
+void marshal_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoEncodeH265ReferenceListsEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint8_t*)&forMarshaling->referenceList0EntryCount, sizeof(uint8_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceList0EntryCount; ++i) {
-            marshal_VkVideoEncodeH265DpbSlotInfoEXT(
-                vkStream, rootType,
-                (const VkVideoEncodeH265DpbSlotInfoEXT*)(forMarshaling->pReferenceList0Entries +
-                                                         i));
-        }
-    }
-    vkStream->write((uint8_t*)&forMarshaling->referenceList1EntryCount, sizeof(uint8_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->referenceList1EntryCount; ++i) {
-            marshal_VkVideoEncodeH265DpbSlotInfoEXT(
-                vkStream, rootType,
-                (const VkVideoEncodeH265DpbSlotInfoEXT*)(forMarshaling->pReferenceList1Entries +
-                                                         i));
-        }
-    }
-    vkStream->write(
-        (const StdVideoEncodeH265ReferenceModifications*)forMarshaling->pReferenceModifications,
-        sizeof(const StdVideoEncodeH265ReferenceModifications));
-}
-
-void unmarshal_VkVideoEncodeH265ReferenceListsEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265ReferenceListsEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((uint8_t*)&forUnmarshaling->referenceList0EntryCount, sizeof(uint8_t));
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pReferenceList0Entries,
-        forUnmarshaling->referenceList0EntryCount * sizeof(const VkVideoEncodeH265DpbSlotInfoEXT));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceList0EntryCount; ++i) {
-            unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
-                vkStream, rootType,
-                (VkVideoEncodeH265DpbSlotInfoEXT*)(forUnmarshaling->pReferenceList0Entries + i));
-        }
-    }
-    vkStream->read((uint8_t*)&forUnmarshaling->referenceList1EntryCount, sizeof(uint8_t));
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pReferenceList1Entries,
-        forUnmarshaling->referenceList1EntryCount * sizeof(const VkVideoEncodeH265DpbSlotInfoEXT));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceList1EntryCount; ++i) {
-            unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
-                vkStream, rootType,
-                (VkVideoEncodeH265DpbSlotInfoEXT*)(forUnmarshaling->pReferenceList1Entries + i));
-        }
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pReferenceModifications,
-                    sizeof(const StdVideoEncodeH265ReferenceModifications));
-    vkStream->read(
-        (StdVideoEncodeH265ReferenceModifications*)forUnmarshaling->pReferenceModifications,
-        sizeof(const StdVideoEncodeH265ReferenceModifications));
-}
-
-void marshal_VkVideoEncodeH265NaluSliceEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           const VkVideoEncodeH265NaluSliceEXT* forMarshaling) {
+    const VkVideoEncodeH265NaluSliceSegmentInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -19124,19 +21394,21 @@ void marshal_VkVideoEncodeH265NaluSliceEXT(VulkanStream* vkStream, VkStructureTy
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
     vkStream->write((uint32_t*)&forMarshaling->ctbCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pReferenceFinalLists;
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pStdReferenceFinalLists;
     vkStream->putBe64(cgen_var_0);
-    if (forMarshaling->pReferenceFinalLists) {
-        marshal_VkVideoEncodeH265ReferenceListsEXT(
-            vkStream, rootType,
-            (const VkVideoEncodeH265ReferenceListsEXT*)(forMarshaling->pReferenceFinalLists));
+    if (forMarshaling->pStdReferenceFinalLists) {
+        vkStream->write(
+            (const StdVideoEncodeH265ReferenceListsInfo*)forMarshaling->pStdReferenceFinalLists,
+            sizeof(const StdVideoEncodeH265ReferenceListsInfo));
     }
-    vkStream->write((const StdVideoEncodeH265SliceHeader*)forMarshaling->pSliceHeaderStd,
-                    sizeof(const StdVideoEncodeH265SliceHeader));
+    vkStream->write(
+        (const StdVideoEncodeH265SliceSegmentHeader*)forMarshaling->pStdSliceSegmentHeader,
+        sizeof(const StdVideoEncodeH265SliceSegmentHeader));
 }
 
-void unmarshal_VkVideoEncodeH265NaluSliceEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             VkVideoEncodeH265NaluSliceEXT* forUnmarshaling) {
+void unmarshal_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH265NaluSliceSegmentInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -19157,19 +21429,19 @@ void unmarshal_VkVideoEncodeH265NaluSliceEXT(VulkanStream* vkStream, VkStructure
     }
     vkStream->read((uint32_t*)&forUnmarshaling->ctbCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    forUnmarshaling->pReferenceFinalLists =
-        (const VkVideoEncodeH265ReferenceListsEXT*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pReferenceFinalLists) {
-        vkStream->alloc((void**)&forUnmarshaling->pReferenceFinalLists,
-                        sizeof(const VkVideoEncodeH265ReferenceListsEXT));
-        unmarshal_VkVideoEncodeH265ReferenceListsEXT(
-            vkStream, rootType,
-            (VkVideoEncodeH265ReferenceListsEXT*)(forUnmarshaling->pReferenceFinalLists));
+    forUnmarshaling->pStdReferenceFinalLists =
+        (const StdVideoEncodeH265ReferenceListsInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pStdReferenceFinalLists) {
+        vkStream->alloc((void**)&forUnmarshaling->pStdReferenceFinalLists,
+                        sizeof(const StdVideoEncodeH265ReferenceListsInfo));
+        vkStream->read(
+            (StdVideoEncodeH265ReferenceListsInfo*)forUnmarshaling->pStdReferenceFinalLists,
+            sizeof(const StdVideoEncodeH265ReferenceListsInfo));
     }
-    vkStream->alloc((void**)&forUnmarshaling->pSliceHeaderStd,
-                    sizeof(const StdVideoEncodeH265SliceHeader));
-    vkStream->read((StdVideoEncodeH265SliceHeader*)forUnmarshaling->pSliceHeaderStd,
-                   sizeof(const StdVideoEncodeH265SliceHeader));
+    vkStream->alloc((void**)&forUnmarshaling->pStdSliceSegmentHeader,
+                    sizeof(const StdVideoEncodeH265SliceSegmentHeader));
+    vkStream->read((StdVideoEncodeH265SliceSegmentHeader*)forUnmarshaling->pStdSliceSegmentHeader,
+                   sizeof(const StdVideoEncodeH265SliceSegmentHeader));
 }
 
 void marshal_VkVideoEncodeH265VclFrameInfoEXT(
@@ -19182,22 +21454,24 @@ void marshal_VkVideoEncodeH265VclFrameInfoEXT(
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
     // WARNING PTR CHECK
-    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pReferenceFinalLists;
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pStdReferenceFinalLists;
     vkStream->putBe64(cgen_var_0);
-    if (forMarshaling->pReferenceFinalLists) {
-        marshal_VkVideoEncodeH265ReferenceListsEXT(
-            vkStream, rootType,
-            (const VkVideoEncodeH265ReferenceListsEXT*)(forMarshaling->pReferenceFinalLists));
+    if (forMarshaling->pStdReferenceFinalLists) {
+        vkStream->write(
+            (const StdVideoEncodeH265ReferenceListsInfo*)forMarshaling->pStdReferenceFinalLists,
+            sizeof(const StdVideoEncodeH265ReferenceListsInfo));
     }
-    vkStream->write((uint32_t*)&forMarshaling->naluSliceEntryCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->naluSliceSegmentEntryCount, sizeof(uint32_t));
     if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceEntryCount; ++i) {
-            marshal_VkVideoEncodeH265NaluSliceEXT(
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->naluSliceSegmentEntryCount; ++i) {
+            marshal_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
                 vkStream, rootType,
-                (const VkVideoEncodeH265NaluSliceEXT*)(forMarshaling->pNaluSliceEntries + i));
+                (const VkVideoEncodeH265NaluSliceSegmentInfoEXT*)(forMarshaling
+                                                                      ->pNaluSliceSegmentEntries +
+                                                                  i));
         }
     }
-    vkStream->write((const StdVideoEncodeH265PictureInfo*)forMarshaling->pCurrentPictureInfo,
+    vkStream->write((const StdVideoEncodeH265PictureInfo*)forMarshaling->pStdPictureInfo,
                     sizeof(const StdVideoEncodeH265PictureInfo));
 }
 
@@ -19222,53 +21496,48 @@ void unmarshal_VkVideoEncodeH265VclFrameInfoEXT(VulkanStream* vkStream, VkStruct
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
     // WARNING PTR CHECK
-    forUnmarshaling->pReferenceFinalLists =
-        (const VkVideoEncodeH265ReferenceListsEXT*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pReferenceFinalLists) {
-        vkStream->alloc((void**)&forUnmarshaling->pReferenceFinalLists,
-                        sizeof(const VkVideoEncodeH265ReferenceListsEXT));
-        unmarshal_VkVideoEncodeH265ReferenceListsEXT(
-            vkStream, rootType,
-            (VkVideoEncodeH265ReferenceListsEXT*)(forUnmarshaling->pReferenceFinalLists));
+    forUnmarshaling->pStdReferenceFinalLists =
+        (const StdVideoEncodeH265ReferenceListsInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pStdReferenceFinalLists) {
+        vkStream->alloc((void**)&forUnmarshaling->pStdReferenceFinalLists,
+                        sizeof(const StdVideoEncodeH265ReferenceListsInfo));
+        vkStream->read(
+            (StdVideoEncodeH265ReferenceListsInfo*)forUnmarshaling->pStdReferenceFinalLists,
+            sizeof(const StdVideoEncodeH265ReferenceListsInfo));
     }
-    vkStream->read((uint32_t*)&forUnmarshaling->naluSliceEntryCount, sizeof(uint32_t));
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pNaluSliceEntries,
-        forUnmarshaling->naluSliceEntryCount * sizeof(const VkVideoEncodeH265NaluSliceEXT));
+    vkStream->read((uint32_t*)&forUnmarshaling->naluSliceSegmentEntryCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pNaluSliceSegmentEntries,
+                    forUnmarshaling->naluSliceSegmentEntryCount *
+                        sizeof(const VkVideoEncodeH265NaluSliceSegmentInfoEXT));
     if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceEntryCount; ++i) {
-            unmarshal_VkVideoEncodeH265NaluSliceEXT(
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceSegmentEntryCount; ++i) {
+            unmarshal_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
                 vkStream, rootType,
-                (VkVideoEncodeH265NaluSliceEXT*)(forUnmarshaling->pNaluSliceEntries + i));
+                (VkVideoEncodeH265NaluSliceSegmentInfoEXT*)(forUnmarshaling
+                                                                ->pNaluSliceSegmentEntries +
+                                                            i));
         }
     }
-    vkStream->alloc((void**)&forUnmarshaling->pCurrentPictureInfo,
+    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
                     sizeof(const StdVideoEncodeH265PictureInfo));
-    vkStream->read((StdVideoEncodeH265PictureInfo*)forUnmarshaling->pCurrentPictureInfo,
+    vkStream->read((StdVideoEncodeH265PictureInfo*)forUnmarshaling->pStdPictureInfo,
                    sizeof(const StdVideoEncodeH265PictureInfo));
 }
 
-void marshal_VkVideoEncodeH265EmitPictureParametersEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoEncodeH265EmitPictureParametersEXT* forMarshaling) {
+void marshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint8_t*)&forMarshaling->vpsId, sizeof(uint8_t));
-    vkStream->write((uint8_t*)&forMarshaling->spsId, sizeof(uint8_t));
-    vkStream->write((VkBool32*)&forMarshaling->emitVpsEnable, sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->emitSpsEnable, sizeof(VkBool32));
-    vkStream->write((uint32_t*)&forMarshaling->ppsIdEntryCount, sizeof(uint32_t));
-    vkStream->write((const uint8_t*)forMarshaling->ppsIdEntries,
-                    forMarshaling->ppsIdEntryCount * sizeof(const uint8_t));
+    vkStream->write((const StdVideoEncodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo,
+                    sizeof(const StdVideoEncodeH265ReferenceInfo));
 }
 
-void unmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265EmitPictureParametersEXT* forUnmarshaling) {
+void unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoEncodeH265DpbSlotInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -19287,19 +21556,14 @@ void unmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((uint8_t*)&forUnmarshaling->vpsId, sizeof(uint8_t));
-    vkStream->read((uint8_t*)&forUnmarshaling->spsId, sizeof(uint8_t));
-    vkStream->read((VkBool32*)&forUnmarshaling->emitVpsEnable, sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->emitSpsEnable, sizeof(VkBool32));
-    vkStream->read((uint32_t*)&forUnmarshaling->ppsIdEntryCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->ppsIdEntries,
-                    forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t));
-    vkStream->read((uint8_t*)forUnmarshaling->ppsIdEntries,
-                   forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t));
+    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
+                    sizeof(const StdVideoEncodeH265ReferenceInfo));
+    vkStream->read((StdVideoEncodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
+                   sizeof(const StdVideoEncodeH265ReferenceInfo));
 }
 
-void marshal_VkVideoEncodeH265ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                         const VkVideoEncodeH265ProfileEXT* forMarshaling) {
+void marshal_VkVideoEncodeH265ProfileInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoEncodeH265ProfileInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -19310,8 +21574,8 @@ void marshal_VkVideoEncodeH265ProfileEXT(VulkanStream* vkStream, VkStructureType
                     sizeof(StdVideoH265ProfileIdc));
 }
 
-void unmarshal_VkVideoEncodeH265ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkVideoEncodeH265ProfileEXT* forUnmarshaling) {
+void unmarshal_VkVideoEncodeH265ProfileInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoEncodeH265ProfileInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -19334,65 +21598,26 @@ void unmarshal_VkVideoEncodeH265ProfileEXT(VulkanStream* vkStream, VkStructureTy
                    sizeof(StdVideoH265ProfileIdc));
 }
 
-#endif
-#ifdef VK_EXT_video_decode_h264
-void marshal_VkVideoDecodeH264ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                         const VkVideoDecodeH264ProfileEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((StdVideoH264ProfileIdc*)&forMarshaling->stdProfileIdc,
-                    sizeof(StdVideoH264ProfileIdc));
-    vkStream->write((VkVideoDecodeH264PictureLayoutFlagsEXT*)&forMarshaling->pictureLayout,
-                    sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT));
-}
-
-void unmarshal_VkVideoDecodeH264ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkVideoDecodeH264ProfileEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc,
-                   sizeof(StdVideoH264ProfileIdc));
-    vkStream->read((VkVideoDecodeH264PictureLayoutFlagsEXT*)&forUnmarshaling->pictureLayout,
-                   sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT));
-}
-
-void marshal_VkVideoDecodeH264CapabilitiesEXT(
+void marshal_VkVideoEncodeH265RateControlInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH264CapabilitiesEXT* forMarshaling) {
+    const VkVideoEncodeH265RateControlInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->maxLevel, sizeof(uint32_t));
-    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->fieldOffsetGranularity));
-    marshal_VkExtensionProperties(vkStream, rootType,
-                                  (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion));
+    vkStream->write((uint32_t*)&forMarshaling->gopFrameCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->idrPeriod, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->consecutiveBFrameCount, sizeof(uint32_t));
+    vkStream->write((VkVideoEncodeH265RateControlStructureEXT*)&forMarshaling->rateControlStructure,
+                    sizeof(VkVideoEncodeH265RateControlStructureEXT));
+    vkStream->write((uint32_t*)&forMarshaling->subLayerCount, sizeof(uint32_t));
 }
 
-void unmarshal_VkVideoDecodeH264CapabilitiesEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkVideoDecodeH264CapabilitiesEXT* forUnmarshaling) {
+void unmarshal_VkVideoEncodeH265RateControlInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH265RateControlInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -19411,286 +21636,74 @@ void unmarshal_VkVideoDecodeH264CapabilitiesEXT(VulkanStream* vkStream, VkStruct
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((uint32_t*)&forUnmarshaling->maxLevel, sizeof(uint32_t));
-    unmarshal_VkOffset2D(vkStream, rootType,
-                         (VkOffset2D*)(&forUnmarshaling->fieldOffsetGranularity));
-    unmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion));
+    vkStream->read((uint32_t*)&forUnmarshaling->gopFrameCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->idrPeriod, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->consecutiveBFrameCount, sizeof(uint32_t));
+    vkStream->read(
+        (VkVideoEncodeH265RateControlStructureEXT*)&forUnmarshaling->rateControlStructure,
+        sizeof(VkVideoEncodeH265RateControlStructureEXT));
+    vkStream->read((uint32_t*)&forUnmarshaling->subLayerCount, sizeof(uint32_t));
 }
 
-void marshal_VkVideoDecodeH264SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH264SessionCreateInfoEXT* forMarshaling) {
+void marshal_VkVideoEncodeH265QpEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkVideoEncodeH265QpEXT* forMarshaling) {
     (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkVideoDecodeH264CreateFlagsEXT*)&forMarshaling->flags,
-                    sizeof(VkVideoDecodeH264CreateFlagsEXT));
-    marshal_VkExtensionProperties(
-        vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion));
+    vkStream->write((int32_t*)&forMarshaling->qpI, sizeof(int32_t));
+    vkStream->write((int32_t*)&forMarshaling->qpP, sizeof(int32_t));
+    vkStream->write((int32_t*)&forMarshaling->qpB, sizeof(int32_t));
 }
 
-void unmarshal_VkVideoDecodeH264SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264SessionCreateInfoEXT* forUnmarshaling) {
+void unmarshal_VkVideoEncodeH265QpEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkVideoEncodeH265QpEXT* forUnmarshaling) {
     (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkVideoDecodeH264CreateFlagsEXT*)&forUnmarshaling->flags,
-                   sizeof(VkVideoDecodeH264CreateFlagsEXT));
-    vkStream->alloc((void**)&forUnmarshaling->pStdExtensionVersion,
-                    sizeof(const VkExtensionProperties));
-    unmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion));
+    vkStream->read((int32_t*)&forUnmarshaling->qpI, sizeof(int32_t));
+    vkStream->read((int32_t*)&forUnmarshaling->qpP, sizeof(int32_t));
+    vkStream->read((int32_t*)&forUnmarshaling->qpB, sizeof(int32_t));
 }
 
-void marshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH264SessionParametersAddInfoEXT* forMarshaling) {
+void marshal_VkVideoEncodeH265FrameSizeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkVideoEncodeH265FrameSizeEXT* forMarshaling) {
     (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->spsStdCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pSpsStd;
-    vkStream->putBe64(cgen_var_0);
-    if (forMarshaling->pSpsStd) {
-        vkStream->write(
-            (const StdVideoH264SequenceParameterSet*)forMarshaling->pSpsStd,
-            forMarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
-    }
-    vkStream->write((uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pPpsStd;
-    vkStream->putBe64(cgen_var_1);
-    if (forMarshaling->pPpsStd) {
-        vkStream->write((const StdVideoH264PictureParameterSet*)forMarshaling->pPpsStd,
-                        forMarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
-    }
+    vkStream->write((uint32_t*)&forMarshaling->frameISize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->framePSize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->frameBSize, sizeof(uint32_t));
 }
 
-void unmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264SessionParametersAddInfoEXT* forUnmarshaling) {
+void unmarshal_VkVideoEncodeH265FrameSizeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkVideoEncodeH265FrameSizeEXT* forUnmarshaling) {
     (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->spsStdCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    forUnmarshaling->pSpsStd =
-        (const StdVideoH264SequenceParameterSet*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pSpsStd) {
-        vkStream->alloc(
-            (void**)&forUnmarshaling->pSpsStd,
-            forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
-        vkStream->read(
-            (StdVideoH264SequenceParameterSet*)forUnmarshaling->pSpsStd,
-            forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->ppsStdCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    forUnmarshaling->pPpsStd =
-        (const StdVideoH264PictureParameterSet*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pPpsStd) {
-        vkStream->alloc(
-            (void**)&forUnmarshaling->pPpsStd,
-            forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
-        vkStream->read(
-            (StdVideoH264PictureParameterSet*)forUnmarshaling->pPpsStd,
-            forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
-    }
+    vkStream->read((uint32_t*)&forUnmarshaling->frameISize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->framePSize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->frameBSize, sizeof(uint32_t));
 }
 
-void marshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+void marshal_VkVideoEncodeH265RateControlLayerInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH264SessionParametersCreateInfoEXT* forMarshaling) {
+    const VkVideoEncodeH265RateControlLayerInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->maxSpsStdCount, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->maxPpsStdCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
-    vkStream->putBe64(cgen_var_0);
-    if (forMarshaling->pParametersAddInfo) {
-        marshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
-            vkStream, rootType,
-            (const VkVideoDecodeH264SessionParametersAddInfoEXT*)(forMarshaling
-                                                                      ->pParametersAddInfo));
-    }
+    vkStream->write((uint32_t*)&forMarshaling->temporalId, sizeof(uint32_t));
+    vkStream->write((VkBool32*)&forMarshaling->useInitialRcQp, sizeof(VkBool32));
+    marshal_VkVideoEncodeH265QpEXT(vkStream, rootType,
+                                   (VkVideoEncodeH265QpEXT*)(&forMarshaling->initialRcQp));
+    vkStream->write((VkBool32*)&forMarshaling->useMinQp, sizeof(VkBool32));
+    marshal_VkVideoEncodeH265QpEXT(vkStream, rootType,
+                                   (VkVideoEncodeH265QpEXT*)(&forMarshaling->minQp));
+    vkStream->write((VkBool32*)&forMarshaling->useMaxQp, sizeof(VkBool32));
+    marshal_VkVideoEncodeH265QpEXT(vkStream, rootType,
+                                   (VkVideoEncodeH265QpEXT*)(&forMarshaling->maxQp));
+    vkStream->write((VkBool32*)&forMarshaling->useMaxFrameSize, sizeof(VkBool32));
+    marshal_VkVideoEncodeH265FrameSizeEXT(
+        vkStream, rootType, (VkVideoEncodeH265FrameSizeEXT*)(&forMarshaling->maxFrameSize));
 }
 
-void unmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+void unmarshal_VkVideoEncodeH265RateControlLayerInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264SessionParametersCreateInfoEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->maxSpsStdCount, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxPpsStdCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    forUnmarshaling->pParametersAddInfo =
-        (const VkVideoDecodeH264SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pParametersAddInfo) {
-        vkStream->alloc((void**)&forUnmarshaling->pParametersAddInfo,
-                        sizeof(const VkVideoDecodeH264SessionParametersAddInfoEXT));
-        unmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
-            vkStream, rootType,
-            (VkVideoDecodeH264SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo));
-    }
-}
-
-void marshal_VkVideoDecodeH264PictureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             const VkVideoDecodeH264PictureInfoEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((const StdVideoDecodeH264PictureInfo*)forMarshaling->pStdPictureInfo,
-                    sizeof(const StdVideoDecodeH264PictureInfo));
-    vkStream->write((uint32_t*)&forMarshaling->slicesCount, sizeof(uint32_t));
-    vkStream->write((const uint32_t*)forMarshaling->pSlicesDataOffsets,
-                    forMarshaling->slicesCount * sizeof(const uint32_t));
-}
-
-void unmarshal_VkVideoDecodeH264PictureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoDecodeH264PictureInfoEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
-                    sizeof(const StdVideoDecodeH264PictureInfo));
-    vkStream->read((StdVideoDecodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo,
-                   sizeof(const StdVideoDecodeH264PictureInfo));
-    vkStream->read((uint32_t*)&forUnmarshaling->slicesCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pSlicesDataOffsets,
-                    forUnmarshaling->slicesCount * sizeof(const uint32_t));
-    vkStream->read((uint32_t*)forUnmarshaling->pSlicesDataOffsets,
-                   forUnmarshaling->slicesCount * sizeof(const uint32_t));
-}
-
-void marshal_VkVideoDecodeH264MvcEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                     const VkVideoDecodeH264MvcEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((const StdVideoDecodeH264Mvc*)forMarshaling->pStdMvc,
-                    sizeof(const StdVideoDecodeH264Mvc));
-}
-
-void unmarshal_VkVideoDecodeH264MvcEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                       VkVideoDecodeH264MvcEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pStdMvc, sizeof(const StdVideoDecodeH264Mvc));
-    vkStream->read((StdVideoDecodeH264Mvc*)forUnmarshaling->pStdMvc,
-                   sizeof(const StdVideoDecodeH264Mvc));
-}
-
-void marshal_VkVideoDecodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             const VkVideoDecodeH264DpbSlotInfoEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((const StdVideoDecodeH264ReferenceInfo*)forMarshaling->pStdReferenceInfo,
-                    sizeof(const StdVideoDecodeH264ReferenceInfo));
-}
-
-void unmarshal_VkVideoDecodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoDecodeH264DpbSlotInfoEXT* forUnmarshaling) {
+    VkVideoEncodeH265RateControlLayerInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -19709,10 +21722,19 @@ void unmarshal_VkVideoDecodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructu
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
-                    sizeof(const StdVideoDecodeH264ReferenceInfo));
-    vkStream->read((StdVideoDecodeH264ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
-                   sizeof(const StdVideoDecodeH264ReferenceInfo));
+    vkStream->read((uint32_t*)&forUnmarshaling->temporalId, sizeof(uint32_t));
+    vkStream->read((VkBool32*)&forUnmarshaling->useInitialRcQp, sizeof(VkBool32));
+    unmarshal_VkVideoEncodeH265QpEXT(vkStream, rootType,
+                                     (VkVideoEncodeH265QpEXT*)(&forUnmarshaling->initialRcQp));
+    vkStream->read((VkBool32*)&forUnmarshaling->useMinQp, sizeof(VkBool32));
+    unmarshal_VkVideoEncodeH265QpEXT(vkStream, rootType,
+                                     (VkVideoEncodeH265QpEXT*)(&forUnmarshaling->minQp));
+    vkStream->read((VkBool32*)&forUnmarshaling->useMaxQp, sizeof(VkBool32));
+    unmarshal_VkVideoEncodeH265QpEXT(vkStream, rootType,
+                                     (VkVideoEncodeH265QpEXT*)(&forUnmarshaling->maxQp));
+    vkStream->read((VkBool32*)&forUnmarshaling->useMaxFrameSize, sizeof(VkBool32));
+    unmarshal_VkVideoEncodeH265FrameSizeEXT(
+        vkStream, rootType, (VkVideoEncodeH265FrameSizeEXT*)(&forUnmarshaling->maxFrameSize));
 }
 
 #endif
@@ -20280,21 +22302,57 @@ void unmarshal_VkViSurfaceCreateInfoNN(VulkanStream* vkStream, VkStructureType r
 #ifdef VK_EXT_shader_subgroup_vote
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
-void marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
+#endif
+#ifdef VK_EXT_astc_decode_mode
+void marshal_VkImageViewASTCDecodeModeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          const VkImageViewASTCDecodeModeEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkFormat*)&forMarshaling->decodeMode, sizeof(VkFormat));
+}
+
+void unmarshal_VkImageViewASTCDecodeModeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            VkImageViewASTCDecodeModeEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkFormat*)&forUnmarshaling->decodeMode, sizeof(VkFormat));
+}
+
+void marshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling) {
+    const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->decodeModeSharedExponent, sizeof(VkBool32));
 }
 
-void unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
+void unmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forUnmarshaling) {
+    VkPhysicalDeviceASTCDecodeFeaturesEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -20313,24 +22371,26 @@ void unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->textureCompressionASTC_HDR, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->decodeModeSharedExponent, sizeof(VkBool32));
 }
 
 #endif
-#ifdef VK_EXT_astc_decode_mode
-void marshal_VkImageViewASTCDecodeModeEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                          const VkImageViewASTCDecodeModeEXT* forMarshaling) {
+#ifdef VK_EXT_pipeline_robustness
+void marshal_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkFormat*)&forMarshaling->decodeMode, sizeof(VkFormat));
+    vkStream->write((VkBool32*)&forMarshaling->pipelineRobustness, sizeof(VkBool32));
 }
 
-void unmarshal_VkImageViewASTCDecodeModeEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                            VkImageViewASTCDecodeModeEXT* forUnmarshaling) {
+void unmarshal_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -20349,24 +22409,34 @@ void unmarshal_VkImageViewASTCDecodeModeEXT(VulkanStream* vkStream, VkStructureT
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkFormat*)&forUnmarshaling->decodeMode, sizeof(VkFormat));
+    vkStream->read((VkBool32*)&forUnmarshaling->pipelineRobustness, sizeof(VkBool32));
 }
 
-void marshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+void marshal_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceASTCDecodeFeaturesEXT* forMarshaling) {
+    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->decodeModeSharedExponent, sizeof(VkBool32));
+    vkStream->write(
+        (VkPipelineRobustnessBufferBehaviorEXT*)&forMarshaling->defaultRobustnessStorageBuffers,
+        sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    vkStream->write(
+        (VkPipelineRobustnessBufferBehaviorEXT*)&forMarshaling->defaultRobustnessUniformBuffers,
+        sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    vkStream->write(
+        (VkPipelineRobustnessBufferBehaviorEXT*)&forMarshaling->defaultRobustnessVertexInputs,
+        sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    vkStream->write((VkPipelineRobustnessImageBehaviorEXT*)&forMarshaling->defaultRobustnessImages,
+                    sizeof(VkPipelineRobustnessImageBehaviorEXT));
 }
 
-void unmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+void unmarshal_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceASTCDecodeFeaturesEXT* forUnmarshaling) {
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -20385,7 +22455,67 @@ void unmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->decodeModeSharedExponent, sizeof(VkBool32));
+    vkStream->read(
+        (VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->defaultRobustnessStorageBuffers,
+        sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    vkStream->read(
+        (VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->defaultRobustnessUniformBuffers,
+        sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    vkStream->read(
+        (VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->defaultRobustnessVertexInputs,
+        sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    vkStream->read((VkPipelineRobustnessImageBehaviorEXT*)&forUnmarshaling->defaultRobustnessImages,
+                   sizeof(VkPipelineRobustnessImageBehaviorEXT));
+}
+
+void marshal_VkPipelineRobustnessCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelineRobustnessCreateInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkPipelineRobustnessBufferBehaviorEXT*)&forMarshaling->storageBuffers,
+                    sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    vkStream->write((VkPipelineRobustnessBufferBehaviorEXT*)&forMarshaling->uniformBuffers,
+                    sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    vkStream->write((VkPipelineRobustnessBufferBehaviorEXT*)&forMarshaling->vertexInputs,
+                    sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    vkStream->write((VkPipelineRobustnessImageBehaviorEXT*)&forMarshaling->images,
+                    sizeof(VkPipelineRobustnessImageBehaviorEXT));
+}
+
+void unmarshal_VkPipelineRobustnessCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineRobustnessCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->storageBuffers,
+                   sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    vkStream->read((VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->uniformBuffers,
+                   sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    vkStream->read((VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->vertexInputs,
+                   sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    vkStream->read((VkPipelineRobustnessImageBehaviorEXT*)&forUnmarshaling->images,
+                   sizeof(VkPipelineRobustnessImageBehaviorEXT));
 }
 
 #endif
@@ -20996,16 +23126,11 @@ void marshal_VkPipelineViewportSwizzleStateCreateInfoNV(
     vkStream->write((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forMarshaling->flags,
                     sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
     vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pViewportSwizzles;
-    vkStream->putBe64(cgen_var_0);
-    if (forMarshaling->pViewportSwizzles) {
-        if (forMarshaling) {
-            for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
-                marshal_VkViewportSwizzleNV(
-                    vkStream, rootType,
-                    (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i));
-            }
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i) {
+            marshal_VkViewportSwizzleNV(
+                vkStream, rootType,
+                (const VkViewportSwizzleNV*)(forMarshaling->pViewportSwizzles + i));
         }
     }
 }
@@ -21034,17 +23159,12 @@ void unmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
     vkStream->read((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forUnmarshaling->flags,
                    sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
     vkStream->read((uint32_t*)&forUnmarshaling->viewportCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    forUnmarshaling->pViewportSwizzles = (const VkViewportSwizzleNV*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pViewportSwizzles) {
-        vkStream->alloc((void**)&forUnmarshaling->pViewportSwizzles,
-                        forUnmarshaling->viewportCount * sizeof(const VkViewportSwizzleNV));
-        if (forUnmarshaling) {
-            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i) {
-                unmarshal_VkViewportSwizzleNV(
-                    vkStream, rootType,
-                    (VkViewportSwizzleNV*)(forUnmarshaling->pViewportSwizzles + i));
-            }
+    vkStream->alloc((void**)&forUnmarshaling->pViewportSwizzles,
+                    forUnmarshaling->viewportCount * sizeof(const VkViewportSwizzleNV));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i) {
+            unmarshal_VkViewportSwizzleNV(
+                vkStream, rootType, (VkViewportSwizzleNV*)(forUnmarshaling->pViewportSwizzles + i));
         }
     }
 }
@@ -21510,8 +23630,6 @@ void unmarshal_VkMacOSSurfaceCreateInfoMVK(VulkanStream* vkStream, VkStructureTy
 }
 
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -21632,40 +23750,26 @@ void marshal_VkDebugUtilsMessengerCallbackDataEXT(
     vkStream->write((int32_t*)&forMarshaling->messageIdNumber, sizeof(int32_t));
     vkStream->putString(forMarshaling->pMessage);
     vkStream->write((uint32_t*)&forMarshaling->queueLabelCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pQueueLabels;
-    vkStream->putBe64(cgen_var_0);
-    if (forMarshaling->pQueueLabels) {
-        if (forMarshaling) {
-            for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i) {
-                marshal_VkDebugUtilsLabelEXT(
-                    vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i));
-            }
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i) {
+            marshal_VkDebugUtilsLabelEXT(
+                vkStream, rootType, (const VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i));
         }
     }
     vkStream->write((uint32_t*)&forMarshaling->cmdBufLabelCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pCmdBufLabels;
-    vkStream->putBe64(cgen_var_1);
-    if (forMarshaling->pCmdBufLabels) {
-        if (forMarshaling) {
-            for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i) {
-                marshal_VkDebugUtilsLabelEXT(
-                    vkStream, rootType, (VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i));
-            }
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i) {
+            marshal_VkDebugUtilsLabelEXT(
+                vkStream, rootType,
+                (const VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i));
         }
     }
     vkStream->write((uint32_t*)&forMarshaling->objectCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pObjects;
-    vkStream->putBe64(cgen_var_2);
-    if (forMarshaling->pObjects) {
-        if (forMarshaling) {
-            for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i) {
-                marshal_VkDebugUtilsObjectNameInfoEXT(
-                    vkStream, rootType,
-                    (VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i));
-            }
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i) {
+            marshal_VkDebugUtilsObjectNameInfoEXT(
+                vkStream, rootType,
+                (const VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i));
         }
     }
 }
@@ -21705,44 +23809,31 @@ void unmarshal_VkDebugUtilsMessengerCallbackDataEXT(
     vkStream->read((int32_t*)&forUnmarshaling->messageIdNumber, sizeof(int32_t));
     vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessage);
     vkStream->read((uint32_t*)&forUnmarshaling->queueLabelCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    forUnmarshaling->pQueueLabels = (VkDebugUtilsLabelEXT*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pQueueLabels) {
-        vkStream->alloc((void**)&forUnmarshaling->pQueueLabels,
-                        forUnmarshaling->queueLabelCount * sizeof(VkDebugUtilsLabelEXT));
-        if (forUnmarshaling) {
-            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueLabelCount; ++i) {
-                unmarshal_VkDebugUtilsLabelEXT(
-                    vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pQueueLabels + i));
-            }
+    vkStream->alloc((void**)&forUnmarshaling->pQueueLabels,
+                    forUnmarshaling->queueLabelCount * sizeof(const VkDebugUtilsLabelEXT));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueLabelCount; ++i) {
+            unmarshal_VkDebugUtilsLabelEXT(
+                vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pQueueLabels + i));
         }
     }
     vkStream->read((uint32_t*)&forUnmarshaling->cmdBufLabelCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    forUnmarshaling->pCmdBufLabels = (VkDebugUtilsLabelEXT*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pCmdBufLabels) {
-        vkStream->alloc((void**)&forUnmarshaling->pCmdBufLabels,
-                        forUnmarshaling->cmdBufLabelCount * sizeof(VkDebugUtilsLabelEXT));
-        if (forUnmarshaling) {
-            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->cmdBufLabelCount; ++i) {
-                unmarshal_VkDebugUtilsLabelEXT(
-                    vkStream, rootType,
-                    (VkDebugUtilsLabelEXT*)(forUnmarshaling->pCmdBufLabels + i));
-            }
+    vkStream->alloc((void**)&forUnmarshaling->pCmdBufLabels,
+                    forUnmarshaling->cmdBufLabelCount * sizeof(const VkDebugUtilsLabelEXT));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->cmdBufLabelCount; ++i) {
+            unmarshal_VkDebugUtilsLabelEXT(
+                vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pCmdBufLabels + i));
         }
     }
     vkStream->read((uint32_t*)&forUnmarshaling->objectCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    forUnmarshaling->pObjects = (VkDebugUtilsObjectNameInfoEXT*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pObjects) {
-        vkStream->alloc((void**)&forUnmarshaling->pObjects,
-                        forUnmarshaling->objectCount * sizeof(VkDebugUtilsObjectNameInfoEXT));
-        if (forUnmarshaling) {
-            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->objectCount; ++i) {
-                unmarshal_VkDebugUtilsObjectNameInfoEXT(
-                    vkStream, rootType,
-                    (VkDebugUtilsObjectNameInfoEXT*)(forUnmarshaling->pObjects + i));
-            }
+    vkStream->alloc((void**)&forUnmarshaling->pObjects,
+                    forUnmarshaling->objectCount * sizeof(const VkDebugUtilsObjectNameInfoEXT));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->objectCount; ++i) {
+            unmarshal_VkDebugUtilsObjectNameInfoEXT(
+                vkStream, rootType,
+                (VkDebugUtilsObjectNameInfoEXT*)(forUnmarshaling->pObjects + i));
         }
     }
 }
@@ -22118,8 +24209,8 @@ void marshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
     vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
     vkStream->write((uint64_t*)&forMarshaling->externalFormat, sizeof(uint64_t));
-    vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->formatFeatures,
-                    sizeof(VkFormatFeatureFlags2KHR));
+    vkStream->write((VkFormatFeatureFlags2*)&forMarshaling->formatFeatures,
+                    sizeof(VkFormatFeatureFlags2));
     marshal_VkComponentMapping(
         vkStream, rootType,
         (VkComponentMapping*)(&forMarshaling->samplerYcbcrConversionComponents));
@@ -22156,8 +24247,8 @@ void unmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
     }
     vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
     vkStream->read((uint64_t*)&forUnmarshaling->externalFormat, sizeof(uint64_t));
-    vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->formatFeatures,
-                   sizeof(VkFormatFeatureFlags2KHR));
+    vkStream->read((VkFormatFeatureFlags2*)&forUnmarshaling->formatFeatures,
+                   sizeof(VkFormatFeatureFlags2));
     unmarshal_VkComponentMapping(
         vkStream, rootType,
         (VkComponentMapping*)(&forUnmarshaling->samplerYcbcrConversionComponents));
@@ -22181,178 +24272,6 @@ void unmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
 #ifdef VK_AMD_shader_fragment_mask
 #endif
 #ifdef VK_EXT_inline_uniform_block
-void marshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->inlineUniformBlock, sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind,
-                    sizeof(VkBool32));
-}
-
-void unmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkBool32*)&forUnmarshaling->inlineUniformBlock, sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind,
-                   sizeof(VkBool32));
-}
-
-void marshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->maxInlineUniformBlockSize, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->maxPerStageDescriptorInlineUniformBlocks,
-                    sizeof(uint32_t));
-    vkStream->write(
-        (uint32_t*)&forMarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
-        sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetInlineUniformBlocks,
-                    sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks,
-                    sizeof(uint32_t));
-}
-
-void unmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->maxInlineUniformBlockSize, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInlineUniformBlocks,
-                   sizeof(uint32_t));
-    vkStream->read(
-        (uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
-        sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetInlineUniformBlocks,
-                   sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks,
-                   sizeof(uint32_t));
-}
-
-void marshal_VkWriteDescriptorSetInlineUniformBlockEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkWriteDescriptorSetInlineUniformBlockEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->dataSize, sizeof(uint32_t));
-    vkStream->write((const void*)forMarshaling->pData,
-                    forMarshaling->dataSize * sizeof(const uint8_t));
-}
-
-void unmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkWriteDescriptorSetInlineUniformBlockEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->dataSize, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pData,
-                    forUnmarshaling->dataSize * sizeof(const uint8_t));
-    vkStream->read((void*)forUnmarshaling->pData,
-                   forUnmarshaling->dataSize * sizeof(const uint8_t));
-}
-
-void marshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->maxInlineUniformBlockBindings, sizeof(uint32_t));
-}
-
-void unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->maxInlineUniformBlockBindings, sizeof(uint32_t));
-}
-
 #endif
 #ifdef VK_EXT_shader_stencil_export
 #endif
@@ -23259,8 +25178,8 @@ void marshal_VkDrmFormatModifierProperties2EXT(
     (void)rootType;
     vkStream->write((uint64_t*)&forMarshaling->drmFormatModifier, sizeof(uint64_t));
     vkStream->write((uint32_t*)&forMarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
-    vkStream->write((VkFormatFeatureFlags2KHR*)&forMarshaling->drmFormatModifierTilingFeatures,
-                    sizeof(VkFormatFeatureFlags2KHR));
+    vkStream->write((VkFormatFeatureFlags2*)&forMarshaling->drmFormatModifierTilingFeatures,
+                    sizeof(VkFormatFeatureFlags2));
 }
 
 void unmarshal_VkDrmFormatModifierProperties2EXT(
@@ -23269,8 +25188,8 @@ void unmarshal_VkDrmFormatModifierProperties2EXT(
     (void)rootType;
     vkStream->read((uint64_t*)&forUnmarshaling->drmFormatModifier, sizeof(uint64_t));
     vkStream->read((uint32_t*)&forUnmarshaling->drmFormatModifierPlaneCount, sizeof(uint32_t));
-    vkStream->read((VkFormatFeatureFlags2KHR*)&forUnmarshaling->drmFormatModifierTilingFeatures,
-                   sizeof(VkFormatFeatureFlags2KHR));
+    vkStream->read((VkFormatFeatureFlags2*)&forUnmarshaling->drmFormatModifierTilingFeatures,
+                   sizeof(VkFormatFeatureFlags2));
 }
 
 void marshal_VkDrmFormatModifierPropertiesList2EXT(
@@ -24568,44 +26487,6 @@ void unmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
 #ifdef VK_QCOM_render_pass_shader_resolve
 #endif
 #ifdef VK_EXT_global_priority
-void marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkQueueGlobalPriorityEXT*)&forMarshaling->globalPriority,
-                    sizeof(VkQueueGlobalPriorityEXT));
-}
-
-void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkQueueGlobalPriorityEXT*)&forUnmarshaling->globalPriority,
-                   sizeof(VkQueueGlobalPriorityEXT));
-}
-
 #endif
 #ifdef VK_EXT_external_memory_host
 void marshal_VkImportMemoryHostPointerInfoEXT(
@@ -24873,343 +26754,6 @@ void unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
 }
 
 #endif
-#ifdef VK_EXT_video_decode_h265
-void marshal_VkVideoDecodeH265ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                         const VkVideoDecodeH265ProfileEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((StdVideoH265ProfileIdc*)&forMarshaling->stdProfileIdc,
-                    sizeof(StdVideoH265ProfileIdc));
-}
-
-void unmarshal_VkVideoDecodeH265ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkVideoDecodeH265ProfileEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((StdVideoH265ProfileIdc*)&forUnmarshaling->stdProfileIdc,
-                   sizeof(StdVideoH265ProfileIdc));
-}
-
-void marshal_VkVideoDecodeH265CapabilitiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH265CapabilitiesEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->maxLevel, sizeof(uint32_t));
-    marshal_VkExtensionProperties(vkStream, rootType,
-                                  (VkExtensionProperties*)(&forMarshaling->stdExtensionVersion));
-}
-
-void unmarshal_VkVideoDecodeH265CapabilitiesEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkVideoDecodeH265CapabilitiesEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->maxLevel, sizeof(uint32_t));
-    unmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion));
-}
-
-void marshal_VkVideoDecodeH265SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH265SessionCreateInfoEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkVideoDecodeH265CreateFlagsEXT*)&forMarshaling->flags,
-                    sizeof(VkVideoDecodeH265CreateFlagsEXT));
-    marshal_VkExtensionProperties(
-        vkStream, rootType, (const VkExtensionProperties*)(forMarshaling->pStdExtensionVersion));
-}
-
-void unmarshal_VkVideoDecodeH265SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265SessionCreateInfoEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkVideoDecodeH265CreateFlagsEXT*)&forUnmarshaling->flags,
-                   sizeof(VkVideoDecodeH265CreateFlagsEXT));
-    vkStream->alloc((void**)&forUnmarshaling->pStdExtensionVersion,
-                    sizeof(const VkExtensionProperties));
-    unmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion));
-}
-
-void marshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH265SessionParametersAddInfoEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->spsStdCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pSpsStd;
-    vkStream->putBe64(cgen_var_0);
-    if (forMarshaling->pSpsStd) {
-        vkStream->write(
-            (const StdVideoH265SequenceParameterSet*)forMarshaling->pSpsStd,
-            forMarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
-    }
-    vkStream->write((uint32_t*)&forMarshaling->ppsStdCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pPpsStd;
-    vkStream->putBe64(cgen_var_1);
-    if (forMarshaling->pPpsStd) {
-        vkStream->write((const StdVideoH265PictureParameterSet*)forMarshaling->pPpsStd,
-                        forMarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
-    }
-}
-
-void unmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265SessionParametersAddInfoEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->spsStdCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    forUnmarshaling->pSpsStd =
-        (const StdVideoH265SequenceParameterSet*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pSpsStd) {
-        vkStream->alloc(
-            (void**)&forUnmarshaling->pSpsStd,
-            forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
-        vkStream->read(
-            (StdVideoH265SequenceParameterSet*)forUnmarshaling->pSpsStd,
-            forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->ppsStdCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    forUnmarshaling->pPpsStd =
-        (const StdVideoH265PictureParameterSet*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pPpsStd) {
-        vkStream->alloc(
-            (void**)&forUnmarshaling->pPpsStd,
-            forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
-        vkStream->read(
-            (StdVideoH265PictureParameterSet*)forUnmarshaling->pPpsStd,
-            forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
-    }
-}
-
-void marshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH265SessionParametersCreateInfoEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->maxSpsStdCount, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->maxPpsStdCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pParametersAddInfo;
-    vkStream->putBe64(cgen_var_0);
-    if (forMarshaling->pParametersAddInfo) {
-        marshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
-            vkStream, rootType,
-            (const VkVideoDecodeH265SessionParametersAddInfoEXT*)(forMarshaling
-                                                                      ->pParametersAddInfo));
-    }
-}
-
-void unmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265SessionParametersCreateInfoEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->maxSpsStdCount, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxPpsStdCount, sizeof(uint32_t));
-    // WARNING PTR CHECK
-    forUnmarshaling->pParametersAddInfo =
-        (const VkVideoDecodeH265SessionParametersAddInfoEXT*)(uintptr_t)vkStream->getBe64();
-    if (forUnmarshaling->pParametersAddInfo) {
-        vkStream->alloc((void**)&forUnmarshaling->pParametersAddInfo,
-                        sizeof(const VkVideoDecodeH265SessionParametersAddInfoEXT));
-        unmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
-            vkStream, rootType,
-            (VkVideoDecodeH265SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo));
-    }
-}
-
-void marshal_VkVideoDecodeH265PictureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             const VkVideoDecodeH265PictureInfoEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((StdVideoDecodeH265PictureInfo*)forMarshaling->pStdPictureInfo,
-                    sizeof(StdVideoDecodeH265PictureInfo));
-    vkStream->write((uint32_t*)&forMarshaling->slicesCount, sizeof(uint32_t));
-    vkStream->write((const uint32_t*)forMarshaling->pSlicesDataOffsets,
-                    forMarshaling->slicesCount * sizeof(const uint32_t));
-}
-
-void unmarshal_VkVideoDecodeH265PictureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoDecodeH265PictureInfoEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
-                    sizeof(StdVideoDecodeH265PictureInfo));
-    vkStream->read((StdVideoDecodeH265PictureInfo*)forUnmarshaling->pStdPictureInfo,
-                   sizeof(StdVideoDecodeH265PictureInfo));
-    vkStream->read((uint32_t*)&forUnmarshaling->slicesCount, sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pSlicesDataOffsets,
-                    forUnmarshaling->slicesCount * sizeof(const uint32_t));
-    vkStream->read((uint32_t*)forUnmarshaling->pSlicesDataOffsets,
-                   forUnmarshaling->slicesCount * sizeof(const uint32_t));
-}
-
-void marshal_VkVideoDecodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             const VkVideoDecodeH265DpbSlotInfoEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((const StdVideoDecodeH265ReferenceInfo*)forMarshaling->pStdReferenceInfo,
-                    sizeof(const StdVideoDecodeH265ReferenceInfo));
-}
-
-void unmarshal_VkVideoDecodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoDecodeH265DpbSlotInfoEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
-                    sizeof(const StdVideoDecodeH265ReferenceInfo));
-    vkStream->read((StdVideoDecodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo,
-                   sizeof(const StdVideoDecodeH265ReferenceInfo));
-}
-
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 void marshal_VkDeviceMemoryOverallocationCreateInfoAMD(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -25440,88 +26984,6 @@ void unmarshal_VkPresentFrameTokenGGP(VulkanStream* vkStream, VkStructureType ro
 
 #endif
 #ifdef VK_EXT_pipeline_creation_feedback
-void marshal_VkPipelineCreationFeedbackEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           const VkPipelineCreationFeedbackEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkPipelineCreationFeedbackFlagsEXT*)&forMarshaling->flags,
-                    sizeof(VkPipelineCreationFeedbackFlagsEXT));
-    vkStream->write((uint64_t*)&forMarshaling->duration, sizeof(uint64_t));
-}
-
-void unmarshal_VkPipelineCreationFeedbackEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             VkPipelineCreationFeedbackEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkPipelineCreationFeedbackFlagsEXT*)&forUnmarshaling->flags,
-                   sizeof(VkPipelineCreationFeedbackFlagsEXT));
-    vkStream->read((uint64_t*)&forUnmarshaling->duration, sizeof(uint64_t));
-}
-
-void marshal_VkPipelineCreationFeedbackCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPipelineCreationFeedbackCreateInfoEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    marshal_VkPipelineCreationFeedbackEXT(
-        vkStream, rootType,
-        (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineCreationFeedback));
-    vkStream->write((uint32_t*)&forMarshaling->pipelineStageCreationFeedbackCount,
-                    sizeof(uint32_t));
-    if (forMarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forMarshaling->pipelineStageCreationFeedbackCount; ++i) {
-            marshal_VkPipelineCreationFeedbackEXT(
-                vkStream, rootType,
-                (VkPipelineCreationFeedbackEXT*)(forMarshaling->pPipelineStageCreationFeedbacks +
-                                                 i));
-        }
-    }
-}
-
-void unmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPipelineCreationFeedbackCreateInfoEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pPipelineCreationFeedback,
-                    sizeof(VkPipelineCreationFeedbackEXT));
-    unmarshal_VkPipelineCreationFeedbackEXT(
-        vkStream, rootType,
-        (VkPipelineCreationFeedbackEXT*)(forUnmarshaling->pPipelineCreationFeedback));
-    vkStream->read((uint32_t*)&forUnmarshaling->pipelineStageCreationFeedbackCount,
-                   sizeof(uint32_t));
-    vkStream->alloc((void**)&forUnmarshaling->pPipelineStageCreationFeedbacks,
-                    forUnmarshaling->pipelineStageCreationFeedbackCount *
-                        sizeof(VkPipelineCreationFeedbackEXT));
-    if (forUnmarshaling) {
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pipelineStageCreationFeedbackCount;
-             ++i) {
-            unmarshal_VkPipelineCreationFeedbackEXT(
-                vkStream, rootType,
-                (VkPipelineCreationFeedbackEXT*)(forUnmarshaling->pPipelineStageCreationFeedbacks +
-                                                 i));
-        }
-    }
-}
-
 #endif
 #ifdef VK_NV_shader_subgroup_partitioned
 #endif
@@ -25682,42 +27144,6 @@ void unmarshal_VkDrawMeshTasksIndirectCommandNV(VulkanStream* vkStream, VkStruct
 
 #endif
 #ifdef VK_NV_fragment_shader_barycentric
-void marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->fragmentShaderBarycentric, sizeof(VkBool32));
-}
-
-void unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkBool32*)&forUnmarshaling->fragmentShaderBarycentric, sizeof(VkBool32));
-}
-
 #endif
 #ifdef VK_NV_shader_image_footprint
 void marshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -26559,124 +27985,6 @@ void unmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
 #ifdef VK_GOOGLE_decorate_string
 #endif
 #ifdef VK_EXT_subgroup_size_control
-void marshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->subgroupSizeControl, sizeof(VkBool32));
-    vkStream->write((VkBool32*)&forMarshaling->computeFullSubgroups, sizeof(VkBool32));
-}
-
-void unmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkBool32*)&forUnmarshaling->subgroupSizeControl, sizeof(VkBool32));
-    vkStream->read((VkBool32*)&forUnmarshaling->computeFullSubgroups, sizeof(VkBool32));
-}
-
-void marshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->minSubgroupSize, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->maxSubgroupSize, sizeof(uint32_t));
-    vkStream->write((uint32_t*)&forMarshaling->maxComputeWorkgroupSubgroups, sizeof(uint32_t));
-    vkStream->write((VkShaderStageFlags*)&forMarshaling->requiredSubgroupSizeStages,
-                    sizeof(VkShaderStageFlags));
-}
-
-void unmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->minSubgroupSize, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxSubgroupSize, sizeof(uint32_t));
-    vkStream->read((uint32_t*)&forUnmarshaling->maxComputeWorkgroupSubgroups, sizeof(uint32_t));
-    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->requiredSubgroupSizeStages,
-                   sizeof(VkShaderStageFlags));
-}
-
-void marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->requiredSubgroupSize, sizeof(uint32_t));
-}
-
-void unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((uint32_t*)&forUnmarshaling->requiredSubgroupSize, sizeof(uint32_t));
-}
-
 #endif
 #ifdef VK_AMD_shader_core_properties2
 void marshal_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -27031,52 +28339,6 @@ void unmarshal_VkBufferDeviceAddressCreateInfoEXT(
 
 #endif
 #ifdef VK_EXT_tooling_info
-void marshal_VkPhysicalDeviceToolPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceToolPropertiesEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((char*)forMarshaling->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-    vkStream->write((char*)forMarshaling->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-    vkStream->write((VkToolPurposeFlagsEXT*)&forMarshaling->purposes,
-                    sizeof(VkToolPurposeFlagsEXT));
-    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    vkStream->write((char*)forMarshaling->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-}
-
-void unmarshal_VkPhysicalDeviceToolPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceToolPropertiesEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((char*)forUnmarshaling->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-    vkStream->read((char*)forUnmarshaling->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-    vkStream->read((VkToolPurposeFlagsEXT*)&forUnmarshaling->purposes,
-                   sizeof(VkToolPurposeFlagsEXT));
-    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    vkStream->read((char*)forUnmarshaling->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-}
-
 #endif
 #ifdef VK_EXT_separate_stencil_usage
 #endif
@@ -28072,22 +29334,63 @@ void unmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
 }
 
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-void marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+void marshal_VkSurfacePresentModeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     const VkSurfacePresentModeEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkPresentModeKHR*)&forMarshaling->presentMode, sizeof(VkPresentModeKHR));
+}
+
+void unmarshal_VkSurfacePresentModeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkSurfacePresentModeEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPresentModeKHR*)&forUnmarshaling->presentMode, sizeof(VkPresentModeKHR));
+}
+
+void marshal_VkSurfacePresentScalingCapabilitiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forMarshaling) {
+    const VkSurfacePresentScalingCapabilitiesEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->shaderDemoteToHelperInvocation, sizeof(VkBool32));
+    vkStream->write((VkPresentScalingFlagsEXT*)&forMarshaling->supportedPresentScaling,
+                    sizeof(VkPresentScalingFlagsEXT));
+    vkStream->write((VkPresentGravityFlagsEXT*)&forMarshaling->supportedPresentGravityX,
+                    sizeof(VkPresentGravityFlagsEXT));
+    vkStream->write((VkPresentGravityFlagsEXT*)&forMarshaling->supportedPresentGravityY,
+                    sizeof(VkPresentGravityFlagsEXT));
+    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->minScaledImageExtent));
+    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxScaledImageExtent));
 }
 
-void unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+void unmarshal_VkSurfacePresentScalingCapabilitiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forUnmarshaling) {
+    VkSurfacePresentScalingCapabilitiesEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -28106,10 +29409,334 @@ void unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->shaderDemoteToHelperInvocation, sizeof(VkBool32));
+    vkStream->read((VkPresentScalingFlagsEXT*)&forUnmarshaling->supportedPresentScaling,
+                   sizeof(VkPresentScalingFlagsEXT));
+    vkStream->read((VkPresentGravityFlagsEXT*)&forUnmarshaling->supportedPresentGravityX,
+                   sizeof(VkPresentGravityFlagsEXT));
+    vkStream->read((VkPresentGravityFlagsEXT*)&forUnmarshaling->supportedPresentGravityY,
+                   sizeof(VkPresentGravityFlagsEXT));
+    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minScaledImageExtent));
+    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxScaledImageExtent));
+}
+
+void marshal_VkSurfacePresentModeCompatibilityEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSurfacePresentModeCompatibilityEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->presentModeCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pPresentModes;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pPresentModes) {
+        vkStream->write((VkPresentModeKHR*)forMarshaling->pPresentModes,
+                        forMarshaling->presentModeCount * sizeof(VkPresentModeKHR));
+    }
+}
+
+void unmarshal_VkSurfacePresentModeCompatibilityEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSurfacePresentModeCompatibilityEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->presentModeCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pPresentModes = (VkPresentModeKHR*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pPresentModes) {
+        vkStream->alloc((void**)&forUnmarshaling->pPresentModes,
+                        forUnmarshaling->presentModeCount * sizeof(VkPresentModeKHR));
+        vkStream->read((VkPresentModeKHR*)forUnmarshaling->pPresentModes,
+                       forUnmarshaling->presentModeCount * sizeof(VkPresentModeKHR));
+    }
 }
 
 #endif
+#ifdef VK_EXT_swapchain_maintenance1
+void marshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->swapchainMaintenance1, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->swapchainMaintenance1, sizeof(VkBool32));
+}
+
+void marshal_VkSwapchainPresentFenceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkSwapchainPresentFenceInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
+    if (forMarshaling->swapchainCount) {
+        uint64_t* cgen_var_0;
+        vkStream->alloc((void**)&cgen_var_0, forMarshaling->swapchainCount * 8);
+        vkStream->handleMapping()->mapHandles_VkFence_u64(forMarshaling->pFences, cgen_var_0,
+                                                          forMarshaling->swapchainCount);
+        vkStream->write((uint64_t*)cgen_var_0, forMarshaling->swapchainCount * 8);
+    }
+}
+
+void unmarshal_VkSwapchainPresentFenceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkSwapchainPresentFenceInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pFences,
+                    forUnmarshaling->swapchainCount * sizeof(const VkFence));
+    if (forUnmarshaling->swapchainCount) {
+        uint64_t* cgen_var_0;
+        vkStream->alloc((void**)&cgen_var_0, forUnmarshaling->swapchainCount * 8);
+        vkStream->read((uint64_t*)cgen_var_0, forUnmarshaling->swapchainCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkFence(
+            cgen_var_0, (VkFence*)forUnmarshaling->pFences, forUnmarshaling->swapchainCount);
+    }
+}
+
+void marshal_VkSwapchainPresentModesCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSwapchainPresentModesCreateInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->presentModeCount, sizeof(uint32_t));
+    vkStream->write((const VkPresentModeKHR*)forMarshaling->pPresentModes,
+                    forMarshaling->presentModeCount * sizeof(const VkPresentModeKHR));
+}
+
+void unmarshal_VkSwapchainPresentModesCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainPresentModesCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->presentModeCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pPresentModes,
+                    forUnmarshaling->presentModeCount * sizeof(const VkPresentModeKHR));
+    vkStream->read((VkPresentModeKHR*)forUnmarshaling->pPresentModes,
+                   forUnmarshaling->presentModeCount * sizeof(const VkPresentModeKHR));
+}
+
+void marshal_VkSwapchainPresentModeInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkSwapchainPresentModeInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
+    vkStream->write((const VkPresentModeKHR*)forMarshaling->pPresentModes,
+                    forMarshaling->swapchainCount * sizeof(const VkPresentModeKHR));
+}
+
+void unmarshal_VkSwapchainPresentModeInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkSwapchainPresentModeInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pPresentModes,
+                    forUnmarshaling->swapchainCount * sizeof(const VkPresentModeKHR));
+    vkStream->read((VkPresentModeKHR*)forUnmarshaling->pPresentModes,
+                   forUnmarshaling->swapchainCount * sizeof(const VkPresentModeKHR));
+}
+
+void marshal_VkSwapchainPresentScalingCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSwapchainPresentScalingCreateInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkPresentScalingFlagsEXT*)&forMarshaling->scalingBehavior,
+                    sizeof(VkPresentScalingFlagsEXT));
+    vkStream->write((VkPresentGravityFlagsEXT*)&forMarshaling->presentGravityX,
+                    sizeof(VkPresentGravityFlagsEXT));
+    vkStream->write((VkPresentGravityFlagsEXT*)&forMarshaling->presentGravityY,
+                    sizeof(VkPresentGravityFlagsEXT));
+}
+
+void unmarshal_VkSwapchainPresentScalingCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainPresentScalingCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkPresentScalingFlagsEXT*)&forUnmarshaling->scalingBehavior,
+                   sizeof(VkPresentScalingFlagsEXT));
+    vkStream->read((VkPresentGravityFlagsEXT*)&forUnmarshaling->presentGravityX,
+                   sizeof(VkPresentGravityFlagsEXT));
+    vkStream->read((VkPresentGravityFlagsEXT*)&forUnmarshaling->presentGravityY,
+                   sizeof(VkPresentGravityFlagsEXT));
+}
+
+void marshal_VkReleaseSwapchainImagesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkReleaseSwapchainImagesInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_0,
+                                                             1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->imageIndexCount, sizeof(uint32_t));
+    vkStream->write((const uint32_t*)forMarshaling->pImageIndices,
+                    forMarshaling->imageIndexCount * sizeof(const uint32_t));
+}
+
+void unmarshal_VkReleaseSwapchainImagesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkReleaseSwapchainImagesInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(
+        &cgen_var_0, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->imageIndexCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pImageIndices,
+                    forUnmarshaling->imageIndexCount * sizeof(const uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->pImageIndices,
+                   forUnmarshaling->imageIndexCount * sizeof(const uint32_t));
+}
+
+#endif
+#ifdef VK_EXT_shader_demote_to_helper_invocation
+#endif
 #ifdef VK_NV_device_generated_commands
 void marshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -28874,56 +30501,6 @@ void unmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
     vkStream->read((VkBool32*)&forUnmarshaling->texelBufferAlignment, sizeof(VkBool32));
 }
 
-void marshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forMarshaling) {
-    (void)rootType;
-    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forMarshaling->sType;
-    }
-    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkDeviceSize*)&forMarshaling->storageTexelBufferOffsetAlignmentBytes,
-                    sizeof(VkDeviceSize));
-    vkStream->write((VkBool32*)&forMarshaling->storageTexelBufferOffsetSingleTexelAlignment,
-                    sizeof(VkBool32));
-    vkStream->write((VkDeviceSize*)&forMarshaling->uniformTexelBufferOffsetAlignmentBytes,
-                    sizeof(VkDeviceSize));
-    vkStream->write((VkBool32*)&forMarshaling->uniformTexelBufferOffsetSingleTexelAlignment,
-                    sizeof(VkBool32));
-}
-
-void unmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forUnmarshaling) {
-    (void)rootType;
-    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    size_t pNext_size;
-    pNext_size = vkStream->getBe32();
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
-    }
-    vkStream->read((VkDeviceSize*)&forUnmarshaling->storageTexelBufferOffsetAlignmentBytes,
-                   sizeof(VkDeviceSize));
-    vkStream->read((VkBool32*)&forUnmarshaling->storageTexelBufferOffsetSingleTexelAlignment,
-                   sizeof(VkBool32));
-    vkStream->read((VkDeviceSize*)&forUnmarshaling->uniformTexelBufferOffsetAlignmentBytes,
-                   sizeof(VkDeviceSize));
-    vkStream->read((VkBool32*)&forUnmarshaling->uniformTexelBufferOffsetSingleTexelAlignment,
-                   sizeof(VkBool32));
-}
-
 #endif
 #ifdef VK_QCOM_render_pass_transform
 void marshal_VkRenderPassTransformBeginInfoQCOM(
@@ -29343,22 +30920,22 @@ void unmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
-#ifdef VK_EXT_private_data
-void marshal_VkPhysicalDevicePrivateDataFeaturesEXT(
+#ifdef VK_NV_present_barrier
+void marshal_VkPhysicalDevicePresentBarrierFeaturesNV(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDevicePrivateDataFeaturesEXT* forMarshaling) {
+    const VkPhysicalDevicePresentBarrierFeaturesNV* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->privateData, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->presentBarrier, sizeof(VkBool32));
 }
 
-void unmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
+void unmarshal_VkPhysicalDevicePresentBarrierFeaturesNV(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDevicePrivateDataFeaturesEXT* forUnmarshaling) {
+    VkPhysicalDevicePresentBarrierFeaturesNV* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -29377,23 +30954,24 @@ void unmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->privateData, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->presentBarrier, sizeof(VkBool32));
 }
 
-void marshal_VkDevicePrivateDataCreateInfoEXT(
+void marshal_VkSurfaceCapabilitiesPresentBarrierNV(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkDevicePrivateDataCreateInfoEXT* forMarshaling) {
+    const VkSurfaceCapabilitiesPresentBarrierNV* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->privateDataSlotRequestCount, sizeof(uint32_t));
+    vkStream->write((VkBool32*)&forMarshaling->presentBarrierSupported, sizeof(VkBool32));
 }
 
-void unmarshal_VkDevicePrivateDataCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkDevicePrivateDataCreateInfoEXT* forUnmarshaling) {
+void unmarshal_VkSurfaceCapabilitiesPresentBarrierNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSurfaceCapabilitiesPresentBarrierNV* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -29412,23 +30990,24 @@ void unmarshal_VkDevicePrivateDataCreateInfoEXT(VulkanStream* vkStream, VkStruct
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((uint32_t*)&forUnmarshaling->privateDataSlotRequestCount, sizeof(uint32_t));
+    vkStream->read((VkBool32*)&forUnmarshaling->presentBarrierSupported, sizeof(VkBool32));
 }
 
-void marshal_VkPrivateDataSlotCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                            const VkPrivateDataSlotCreateInfoEXT* forMarshaling) {
+void marshal_VkSwapchainPresentBarrierCreateInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSwapchainPresentBarrierCreateInfoNV* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkPrivateDataSlotCreateFlagsEXT*)&forMarshaling->flags,
-                    sizeof(VkPrivateDataSlotCreateFlagsEXT));
+    vkStream->write((VkBool32*)&forMarshaling->presentBarrierEnable, sizeof(VkBool32));
 }
 
-void unmarshal_VkPrivateDataSlotCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                              VkPrivateDataSlotCreateInfoEXT* forUnmarshaling) {
+void unmarshal_VkSwapchainPresentBarrierCreateInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainPresentBarrierCreateInfoNV* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -29447,27 +31026,30 @@ void unmarshal_VkPrivateDataSlotCreateInfoEXT(VulkanStream* vkStream, VkStructur
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkPrivateDataSlotCreateFlagsEXT*)&forUnmarshaling->flags,
-                   sizeof(VkPrivateDataSlotCreateFlagsEXT));
+    vkStream->read((VkBool32*)&forUnmarshaling->presentBarrierEnable, sizeof(VkBool32));
 }
 
 #endif
+#ifdef VK_EXT_private_data
+#endif
 #ifdef VK_EXT_pipeline_creation_cache_control
-void marshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+#endif
+#ifdef VK_NV_device_diagnostics_config
+void marshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forMarshaling) {
+    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->pipelineCreationCacheControl, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->diagnosticsConfig, sizeof(VkBool32));
 }
 
-void unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+void unmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forUnmarshaling) {
+    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -29486,26 +31068,209 @@ void unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->pipelineCreationCacheControl, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->diagnosticsConfig, sizeof(VkBool32));
+}
+
+void marshal_VkDeviceDiagnosticsConfigCreateInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDeviceDiagnosticsConfigFlagsNV*)&forMarshaling->flags,
+                    sizeof(VkDeviceDiagnosticsConfigFlagsNV));
+}
+
+void unmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceDiagnosticsConfigCreateInfoNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceDiagnosticsConfigFlagsNV*)&forUnmarshaling->flags,
+                   sizeof(VkDeviceDiagnosticsConfigFlagsNV));
 }
 
 #endif
-#ifdef VK_NV_device_diagnostics_config
-void marshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+#ifdef VK_QCOM_render_pass_store_ops
+#endif
+#ifdef VK_NV_low_latency
+void marshal_VkQueryLowLatencySupportNV(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkQueryLowLatencySupportNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((void*)forMarshaling->pQueriedLowLatencyData, sizeof(uint8_t));
+}
+
+void unmarshal_VkQueryLowLatencySupportNV(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkQueryLowLatencySupportNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pQueriedLowLatencyData, sizeof(uint8_t));
+    vkStream->read((void*)forUnmarshaling->pQueriedLowLatencyData, sizeof(uint8_t));
+}
+
+#endif
+#ifdef VK_EXT_metal_objects
+void marshal_VkExportMetalObjectCreateInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forMarshaling) {
+    const VkExportMetalObjectCreateInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->diagnosticsConfig, sizeof(VkBool32));
+    vkStream->write((VkExportMetalObjectTypeFlagBitsEXT*)&forMarshaling->exportObjectType,
+                    sizeof(VkExportMetalObjectTypeFlagBitsEXT));
 }
 
-void unmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+void unmarshal_VkExportMetalObjectCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkExportMetalObjectCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkExportMetalObjectTypeFlagBitsEXT*)&forUnmarshaling->exportObjectType,
+                   sizeof(VkExportMetalObjectTypeFlagBitsEXT));
+}
+
+void marshal_VkExportMetalObjectsInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkExportMetalObjectsInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+}
+
+void unmarshal_VkExportMetalObjectsInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkExportMetalObjectsInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+}
+
+void marshal_VkExportMetalDeviceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkExportMetalDeviceInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((MTLDevice_id*)&forMarshaling->mtlDevice, sizeof(MTLDevice_id));
+}
+
+void unmarshal_VkExportMetalDeviceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkExportMetalDeviceInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((MTLDevice_id*)&forUnmarshaling->mtlDevice, sizeof(MTLDevice_id));
+}
+
+void marshal_VkExportMetalCommandQueueInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forUnmarshaling) {
+    const VkExportMetalCommandQueueInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkQueue_u64(&forMarshaling->queue, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((MTLCommandQueue_id*)&forMarshaling->mtlCommandQueue,
+                    sizeof(MTLCommandQueue_id));
+}
+
+void unmarshal_VkExportMetalCommandQueueInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkExportMetalCommandQueueInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -29524,25 +31289,423 @@ void unmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->diagnosticsConfig, sizeof(VkBool32));
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkQueue(&cgen_var_0,
+                                                      (VkQueue*)&forUnmarshaling->queue, 1);
+    vkStream->read((MTLCommandQueue_id*)&forUnmarshaling->mtlCommandQueue,
+                   sizeof(MTLCommandQueue_id));
 }
 
-void marshal_VkDeviceDiagnosticsConfigCreateInfoNV(
+void marshal_VkExportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkExportMetalBufferInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_0,
+                                                             1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((MTLBuffer_id*)&forMarshaling->mtlBuffer, sizeof(MTLBuffer_id));
+}
+
+void unmarshal_VkExportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkExportMetalBufferInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(
+        &cgen_var_0, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+    vkStream->read((MTLBuffer_id*)&forUnmarshaling->mtlBuffer, sizeof(MTLBuffer_id));
+}
+
+void marshal_VkImportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkImportMetalBufferInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((MTLBuffer_id*)&forMarshaling->mtlBuffer, sizeof(MTLBuffer_id));
+}
+
+void unmarshal_VkImportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkImportMetalBufferInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((MTLBuffer_id*)&forUnmarshaling->mtlBuffer, sizeof(MTLBuffer_id));
+}
+
+void marshal_VkExportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkExportMetalTextureInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    uint64_t cgen_var_1;
+    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_1,
+                                                          1);
+    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
+    uint64_t cgen_var_2;
+    vkStream->handleMapping()->mapHandles_VkBufferView_u64(&forMarshaling->bufferView, &cgen_var_2,
+                                                           1);
+    vkStream->write((uint64_t*)&cgen_var_2, 1 * 8);
+    vkStream->write((VkImageAspectFlagBits*)&forMarshaling->plane, sizeof(VkImageAspectFlagBits));
+    vkStream->write((MTLTexture_id*)&forMarshaling->mtlTexture, sizeof(MTLTexture_id));
+}
+
+void unmarshal_VkExportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkExportMetalTextureInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+                                                      (VkImage*)&forUnmarshaling->image, 1);
+    uint64_t cgen_var_1;
+    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImageView(
+        &cgen_var_1, (VkImageView*)&forUnmarshaling->imageView, 1);
+    uint64_t cgen_var_2;
+    vkStream->read((uint64_t*)&cgen_var_2, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBufferView(
+        &cgen_var_2, (VkBufferView*)&forUnmarshaling->bufferView, 1);
+    vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->plane, sizeof(VkImageAspectFlagBits));
+    vkStream->read((MTLTexture_id*)&forUnmarshaling->mtlTexture, sizeof(MTLTexture_id));
+}
+
+void marshal_VkImportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkImportMetalTextureInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkImageAspectFlagBits*)&forMarshaling->plane, sizeof(VkImageAspectFlagBits));
+    vkStream->write((MTLTexture_id*)&forMarshaling->mtlTexture, sizeof(MTLTexture_id));
+}
+
+void unmarshal_VkImportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkImportMetalTextureInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkImageAspectFlagBits*)&forUnmarshaling->plane, sizeof(VkImageAspectFlagBits));
+    vkStream->read((MTLTexture_id*)&forUnmarshaling->mtlTexture, sizeof(MTLTexture_id));
+}
+
+void marshal_VkExportMetalIOSurfaceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkExportMetalIOSurfaceInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((IOSurfaceRef*)&forMarshaling->ioSurface, sizeof(IOSurfaceRef));
+}
+
+void unmarshal_VkExportMetalIOSurfaceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkExportMetalIOSurfaceInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+                                                      (VkImage*)&forUnmarshaling->image, 1);
+    vkStream->read((IOSurfaceRef*)&forUnmarshaling->ioSurface, sizeof(IOSurfaceRef));
+}
+
+void marshal_VkImportMetalIOSurfaceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkImportMetalIOSurfaceInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((IOSurfaceRef*)&forMarshaling->ioSurface, sizeof(IOSurfaceRef));
+}
+
+void unmarshal_VkImportMetalIOSurfaceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkImportMetalIOSurfaceInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((IOSurfaceRef*)&forUnmarshaling->ioSurface, sizeof(IOSurfaceRef));
+}
+
+void marshal_VkExportMetalSharedEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkExportMetalSharedEventInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_0,
+                                                          1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    uint64_t cgen_var_1;
+    vkStream->handleMapping()->mapHandles_VkEvent_u64(&forMarshaling->event, &cgen_var_1, 1);
+    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->write((MTLSharedEvent_id*)&forMarshaling->mtlSharedEvent, sizeof(MTLSharedEvent_id));
+}
+
+void unmarshal_VkExportMetalSharedEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkExportMetalSharedEventInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(
+        &cgen_var_0, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+    uint64_t cgen_var_1;
+    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkEvent(&cgen_var_1,
+                                                      (VkEvent*)&forUnmarshaling->event, 1);
+    vkStream->read((MTLSharedEvent_id*)&forUnmarshaling->mtlSharedEvent, sizeof(MTLSharedEvent_id));
+}
+
+void marshal_VkImportMetalSharedEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkImportMetalSharedEventInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((MTLSharedEvent_id*)&forMarshaling->mtlSharedEvent, sizeof(MTLSharedEvent_id));
+}
+
+void unmarshal_VkImportMetalSharedEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkImportMetalSharedEventInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((MTLSharedEvent_id*)&forUnmarshaling->mtlSharedEvent, sizeof(MTLSharedEvent_id));
+}
+
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void marshal_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkDeviceDiagnosticsConfigCreateInfoNV* forMarshaling) {
+    const VkPhysicalDeviceDescriptorBufferPropertiesEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkDeviceDiagnosticsConfigFlagsNV*)&forMarshaling->flags,
-                    sizeof(VkDeviceDiagnosticsConfigFlagsNV));
+    vkStream->write((VkBool32*)&forMarshaling->combinedImageSamplerDescriptorSingleArray,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->bufferlessPushDescriptors, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->allowSamplerImageViewPostSubmitCreation,
+                    sizeof(VkBool32));
+    vkStream->write((VkDeviceSize*)&forMarshaling->descriptorBufferOffsetAlignment,
+                    sizeof(VkDeviceSize));
+    vkStream->write((uint32_t*)&forMarshaling->maxDescriptorBufferBindings, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxResourceDescriptorBufferBindings,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxSamplerDescriptorBufferBindings,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxEmbeddedImmutableSamplerBindings,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxEmbeddedImmutableSamplers, sizeof(uint32_t));
+    uint64_t cgen_var_0 = (uint64_t)forMarshaling->bufferCaptureReplayDescriptorDataSize;
+    vkStream->putBe64(cgen_var_0);
+    uint64_t cgen_var_1 = (uint64_t)forMarshaling->imageCaptureReplayDescriptorDataSize;
+    vkStream->putBe64(cgen_var_1);
+    uint64_t cgen_var_2 = (uint64_t)forMarshaling->imageViewCaptureReplayDescriptorDataSize;
+    vkStream->putBe64(cgen_var_2);
+    uint64_t cgen_var_3 = (uint64_t)forMarshaling->samplerCaptureReplayDescriptorDataSize;
+    vkStream->putBe64(cgen_var_3);
+    uint64_t cgen_var_4 =
+        (uint64_t)forMarshaling->accelerationStructureCaptureReplayDescriptorDataSize;
+    vkStream->putBe64(cgen_var_4);
+    uint64_t cgen_var_5 = (uint64_t)forMarshaling->samplerDescriptorSize;
+    vkStream->putBe64(cgen_var_5);
+    uint64_t cgen_var_6 = (uint64_t)forMarshaling->combinedImageSamplerDescriptorSize;
+    vkStream->putBe64(cgen_var_6);
+    uint64_t cgen_var_7 = (uint64_t)forMarshaling->sampledImageDescriptorSize;
+    vkStream->putBe64(cgen_var_7);
+    uint64_t cgen_var_8 = (uint64_t)forMarshaling->storageImageDescriptorSize;
+    vkStream->putBe64(cgen_var_8);
+    uint64_t cgen_var_9 = (uint64_t)forMarshaling->uniformTexelBufferDescriptorSize;
+    vkStream->putBe64(cgen_var_9);
+    uint64_t cgen_var_10 = (uint64_t)forMarshaling->robustUniformTexelBufferDescriptorSize;
+    vkStream->putBe64(cgen_var_10);
+    uint64_t cgen_var_11 = (uint64_t)forMarshaling->storageTexelBufferDescriptorSize;
+    vkStream->putBe64(cgen_var_11);
+    uint64_t cgen_var_12 = (uint64_t)forMarshaling->robustStorageTexelBufferDescriptorSize;
+    vkStream->putBe64(cgen_var_12);
+    uint64_t cgen_var_13 = (uint64_t)forMarshaling->uniformBufferDescriptorSize;
+    vkStream->putBe64(cgen_var_13);
+    uint64_t cgen_var_14 = (uint64_t)forMarshaling->robustUniformBufferDescriptorSize;
+    vkStream->putBe64(cgen_var_14);
+    uint64_t cgen_var_15 = (uint64_t)forMarshaling->storageBufferDescriptorSize;
+    vkStream->putBe64(cgen_var_15);
+    uint64_t cgen_var_16 = (uint64_t)forMarshaling->robustStorageBufferDescriptorSize;
+    vkStream->putBe64(cgen_var_16);
+    uint64_t cgen_var_17 = (uint64_t)forMarshaling->inputAttachmentDescriptorSize;
+    vkStream->putBe64(cgen_var_17);
+    uint64_t cgen_var_18 = (uint64_t)forMarshaling->accelerationStructureDescriptorSize;
+    vkStream->putBe64(cgen_var_18);
+    vkStream->write((VkDeviceSize*)&forMarshaling->maxSamplerDescriptorBufferRange,
+                    sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->maxResourceDescriptorBufferRange,
+                    sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->samplerDescriptorBufferAddressSpaceSize,
+                    sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->resourceDescriptorBufferAddressSpaceSize,
+                    sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->descriptorBufferAddressSpaceSize,
+                    sizeof(VkDeviceSize));
 }
 
-void unmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
+void unmarshal_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceDiagnosticsConfigCreateInfoNV* forUnmarshaling) {
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -29561,12 +31724,715 @@ void unmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkDeviceDiagnosticsConfigFlagsNV*)&forUnmarshaling->flags,
-                   sizeof(VkDeviceDiagnosticsConfigFlagsNV));
+    vkStream->read((VkBool32*)&forUnmarshaling->combinedImageSamplerDescriptorSingleArray,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->bufferlessPushDescriptors, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->allowSamplerImageViewPostSubmitCreation,
+                   sizeof(VkBool32));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->descriptorBufferOffsetAlignment,
+                   sizeof(VkDeviceSize));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDescriptorBufferBindings, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxResourceDescriptorBufferBindings,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxSamplerDescriptorBufferBindings,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxEmbeddedImmutableSamplerBindings,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxEmbeddedImmutableSamplers, sizeof(uint32_t));
+    forUnmarshaling->bufferCaptureReplayDescriptorDataSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->imageCaptureReplayDescriptorDataSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->imageViewCaptureReplayDescriptorDataSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->samplerCaptureReplayDescriptorDataSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->accelerationStructureCaptureReplayDescriptorDataSize =
+        (size_t)vkStream->getBe64();
+    forUnmarshaling->samplerDescriptorSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->combinedImageSamplerDescriptorSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->sampledImageDescriptorSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->storageImageDescriptorSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->uniformTexelBufferDescriptorSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->robustUniformTexelBufferDescriptorSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->storageTexelBufferDescriptorSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->robustStorageTexelBufferDescriptorSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->uniformBufferDescriptorSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->robustUniformBufferDescriptorSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->storageBufferDescriptorSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->robustStorageBufferDescriptorSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->inputAttachmentDescriptorSize = (size_t)vkStream->getBe64();
+    forUnmarshaling->accelerationStructureDescriptorSize = (size_t)vkStream->getBe64();
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxSamplerDescriptorBufferRange,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->maxResourceDescriptorBufferRange,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->samplerDescriptorBufferAddressSpaceSize,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->resourceDescriptorBufferAddressSpaceSize,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->descriptorBufferAddressSpaceSize,
+                   sizeof(VkDeviceSize));
+}
+
+void marshal_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0 = (uint64_t)forMarshaling->combinedImageSamplerDensityMapDescriptorSize;
+    vkStream->putBe64(cgen_var_0);
+}
+
+void unmarshal_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    forUnmarshaling->combinedImageSamplerDensityMapDescriptorSize = (size_t)vkStream->getBe64();
+}
+
+void marshal_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorBufferFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBuffer, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBufferCaptureReplay, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBufferImageLayoutIgnored,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->descriptorBufferPushDescriptors, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBuffer, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBufferCaptureReplay, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBufferImageLayoutIgnored,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorBufferPushDescriptors, sizeof(VkBool32));
+}
+
+void marshal_VkDescriptorAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkDescriptorAddressInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDeviceAddress*)&forMarshaling->address, sizeof(VkDeviceAddress));
+    vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
+    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+}
+
+void unmarshal_VkDescriptorAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkDescriptorAddressInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->address, sizeof(VkDeviceAddress));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
+    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+}
+
+void marshal_VkDescriptorBufferBindingInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDescriptorBufferBindingInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDeviceAddress*)&forMarshaling->address, sizeof(VkDeviceAddress));
+    vkStream->write((VkBufferUsageFlags*)&forMarshaling->usage, sizeof(VkBufferUsageFlags));
+}
+
+void unmarshal_VkDescriptorBufferBindingInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkDescriptorBufferBindingInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->address, sizeof(VkDeviceAddress));
+    vkStream->read((VkBufferUsageFlags*)&forUnmarshaling->usage, sizeof(VkBufferUsageFlags));
+}
+
+void marshal_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+}
+
+void unmarshal_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
+}
+
+void marshal_VkDescriptorDataEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                 const VkDescriptorDataEXT* forMarshaling) {
+    (void)rootType;
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkSampler_u64(forMarshaling->pSampler, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 8);
+}
+
+void unmarshal_VkDescriptorDataEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                   VkDescriptorDataEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->alloc((void**)&forUnmarshaling->pSampler, sizeof(const VkSampler));
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_0,
+                                                        (VkSampler*)forUnmarshaling->pSampler, 1);
+}
+
+void marshal_VkDescriptorGetInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkDescriptorGetInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDescriptorType*)&forMarshaling->type, sizeof(VkDescriptorType));
+    marshal_VkDescriptorDataEXT(vkStream, rootType, (VkDescriptorDataEXT*)(&forMarshaling->data));
+}
+
+void unmarshal_VkDescriptorGetInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkDescriptorGetInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDescriptorType*)&forUnmarshaling->type, sizeof(VkDescriptorType));
+    unmarshal_VkDescriptorDataEXT(vkStream, rootType,
+                                  (VkDescriptorDataEXT*)(&forUnmarshaling->data));
+}
+
+void marshal_VkBufferCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkBufferCaptureDescriptorDataInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+}
+
+void unmarshal_VkBufferCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkBufferCaptureDescriptorDataInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
+}
+
+void marshal_VkImageCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkImageCaptureDescriptorDataInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+}
+
+void unmarshal_VkImageCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageCaptureDescriptorDataInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_0,
+                                                      (VkImage*)&forUnmarshaling->image, 1);
+}
+
+void marshal_VkImageViewCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkImageViewCaptureDescriptorDataInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_0,
+                                                          1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+}
+
+void unmarshal_VkImageViewCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageViewCaptureDescriptorDataInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImageView(
+        &cgen_var_0, (VkImageView*)&forUnmarshaling->imageView, 1);
+}
+
+void marshal_VkSamplerCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSamplerCaptureDescriptorDataInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkSampler_u64(&forMarshaling->sampler, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+}
+
+void unmarshal_VkSamplerCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSamplerCaptureDescriptorDataInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_0,
+                                                        (VkSampler*)&forUnmarshaling->sampler, 1);
+}
+
+void marshal_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkOpaqueCaptureDescriptorDataCreateInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((const void*)forMarshaling->opaqueCaptureDescriptorData, sizeof(const uint8_t));
+}
+
+void unmarshal_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpaqueCaptureDescriptorDataCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->opaqueCaptureDescriptorData, sizeof(const uint8_t));
+    vkStream->read((void*)forUnmarshaling->opaqueCaptureDescriptorData, sizeof(const uint8_t));
+}
+
+void marshal_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkAccelerationStructureKHR_u64(
+        &forMarshaling->accelerationStructure, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    uint64_t cgen_var_1;
+    vkStream->handleMapping()->mapHandles_VkAccelerationStructureNV_u64(
+        &forMarshaling->accelerationStructureNV, &cgen_var_1, 1);
+    vkStream->write((uint64_t*)&cgen_var_1, 1 * 8);
+}
+
+void unmarshal_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureKHR(
+        &cgen_var_0, (VkAccelerationStructureKHR*)&forUnmarshaling->accelerationStructure, 1);
+    uint64_t cgen_var_1;
+    vkStream->read((uint64_t*)&cgen_var_1, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkAccelerationStructureNV(
+        &cgen_var_1, (VkAccelerationStructureNV*)&forUnmarshaling->accelerationStructureNV, 1);
 }
 
 #endif
-#ifdef VK_QCOM_render_pass_store_ops
+#ifdef VK_EXT_graphics_pipeline_library
+void marshal_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->graphicsPipelineLibrary, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->graphicsPipelineLibrary, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->graphicsPipelineLibraryFastLinking,
+                    sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->graphicsPipelineLibraryIndependentInterpolationDecoration,
+        sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->graphicsPipelineLibraryFastLinking,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->graphicsPipelineLibraryIndependentInterpolationDecoration,
+        sizeof(VkBool32));
+}
+
+void marshal_VkGraphicsPipelineLibraryCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkGraphicsPipelineLibraryCreateInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkGraphicsPipelineLibraryFlagsEXT*)&forMarshaling->flags,
+                    sizeof(VkGraphicsPipelineLibraryFlagsEXT));
+}
+
+void unmarshal_VkGraphicsPipelineLibraryCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkGraphicsPipelineLibraryCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkGraphicsPipelineLibraryFlagsEXT*)&forUnmarshaling->flags,
+                   sizeof(VkGraphicsPipelineLibraryFlagsEXT));
+}
+
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+void marshal_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->shaderEarlyAndLateFragmentTests, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderEarlyAndLateFragmentTests, sizeof(VkBool32));
+}
+
 #endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void marshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -30166,21 +33032,23 @@ void unmarshal_VkCopyCommandTransformInfoQCOM(VulkanStream* vkStream, VkStructur
 
 #endif
 #ifdef VK_EXT_image_robustness
-void marshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+#endif
+#ifdef VK_EXT_image_compression_control
+void marshal_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceImageRobustnessFeaturesEXT* forMarshaling) {
+    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->robustImageAccess, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->imageCompressionControl, sizeof(VkBool32));
 }
 
-void unmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+void unmarshal_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceImageRobustnessFeaturesEXT* forUnmarshaling) {
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -30199,7 +33067,216 @@ void unmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->robustImageAccess, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->imageCompressionControl, sizeof(VkBool32));
+}
+
+void marshal_VkImageCompressionControlEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          const VkImageCompressionControlEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkImageCompressionFlagsEXT*)&forMarshaling->flags,
+                    sizeof(VkImageCompressionFlagsEXT));
+    vkStream->write((uint32_t*)&forMarshaling->compressionControlPlaneCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pFixedRateFlags;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pFixedRateFlags) {
+        vkStream->write((VkImageCompressionFixedRateFlagsEXT*)forMarshaling->pFixedRateFlags,
+                        forMarshaling->compressionControlPlaneCount *
+                            sizeof(VkImageCompressionFixedRateFlagsEXT));
+    }
+}
+
+void unmarshal_VkImageCompressionControlEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            VkImageCompressionControlEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkImageCompressionFlagsEXT*)&forUnmarshaling->flags,
+                   sizeof(VkImageCompressionFlagsEXT));
+    vkStream->read((uint32_t*)&forUnmarshaling->compressionControlPlaneCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pFixedRateFlags =
+        (VkImageCompressionFixedRateFlagsEXT*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pFixedRateFlags) {
+        vkStream->alloc((void**)&forUnmarshaling->pFixedRateFlags,
+                        forUnmarshaling->compressionControlPlaneCount *
+                            sizeof(VkImageCompressionFixedRateFlagsEXT));
+        vkStream->read((VkImageCompressionFixedRateFlagsEXT*)forUnmarshaling->pFixedRateFlags,
+                       forUnmarshaling->compressionControlPlaneCount *
+                           sizeof(VkImageCompressionFixedRateFlagsEXT));
+    }
+}
+
+void marshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     const VkSubresourceLayout2EXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkSubresourceLayout(vkStream, rootType,
+                                (VkSubresourceLayout*)(&forMarshaling->subresourceLayout));
+}
+
+void unmarshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkSubresourceLayout2EXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkSubresourceLayout(vkStream, rootType,
+                                  (VkSubresourceLayout*)(&forUnmarshaling->subresourceLayout));
+}
+
+void marshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkImageSubresource2EXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkImageSubresource(vkStream, rootType,
+                               (VkImageSubresource*)(&forMarshaling->imageSubresource));
+}
+
+void unmarshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkImageSubresource2EXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkImageSubresource(vkStream, rootType,
+                                 (VkImageSubresource*)(&forUnmarshaling->imageSubresource));
+}
+
+void marshal_VkImageCompressionPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkImageCompressionPropertiesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkImageCompressionFlagsEXT*)&forMarshaling->imageCompressionFlags,
+                    sizeof(VkImageCompressionFlagsEXT));
+    vkStream->write(
+        (VkImageCompressionFixedRateFlagsEXT*)&forMarshaling->imageCompressionFixedRateFlags,
+        sizeof(VkImageCompressionFixedRateFlagsEXT));
+}
+
+void unmarshal_VkImageCompressionPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkImageCompressionPropertiesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkImageCompressionFlagsEXT*)&forUnmarshaling->imageCompressionFlags,
+                   sizeof(VkImageCompressionFlagsEXT));
+    vkStream->read(
+        (VkImageCompressionFixedRateFlagsEXT*)&forUnmarshaling->imageCompressionFixedRateFlags,
+        sizeof(VkImageCompressionFixedRateFlagsEXT));
+}
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+void marshal_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->attachmentFeedbackLoopLayout, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->attachmentFeedbackLoopLayout, sizeof(VkBool32));
 }
 
 #endif
@@ -30243,6 +33320,276 @@ void unmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
 }
 
 #endif
+#ifdef VK_EXT_device_fault
+void marshal_VkPhysicalDeviceFaultFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceFaultFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->deviceFault, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->deviceFaultVendorBinary, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceFaultFeaturesEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkPhysicalDeviceFaultFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->deviceFault, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->deviceFaultVendorBinary, sizeof(VkBool32));
+}
+
+void marshal_VkDeviceFaultCountsEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkDeviceFaultCountsEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->addressInfoCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->vendorInfoCount, sizeof(uint32_t));
+    vkStream->write((VkDeviceSize*)&forMarshaling->vendorBinarySize, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkDeviceFaultCountsEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkDeviceFaultCountsEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->addressInfoCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->vendorInfoCount, sizeof(uint32_t));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->vendorBinarySize, sizeof(VkDeviceSize));
+}
+
+void marshal_VkDeviceFaultAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkDeviceFaultAddressInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkDeviceFaultAddressTypeEXT*)&forMarshaling->addressType,
+                    sizeof(VkDeviceFaultAddressTypeEXT));
+    vkStream->write((VkDeviceAddress*)&forMarshaling->reportedAddress, sizeof(VkDeviceAddress));
+    vkStream->write((VkDeviceSize*)&forMarshaling->addressPrecision, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkDeviceFaultAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkDeviceFaultAddressInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkDeviceFaultAddressTypeEXT*)&forUnmarshaling->addressType,
+                   sizeof(VkDeviceFaultAddressTypeEXT));
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->reportedAddress, sizeof(VkDeviceAddress));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->addressPrecision, sizeof(VkDeviceSize));
+}
+
+void marshal_VkDeviceFaultVendorInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkDeviceFaultVendorInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    vkStream->write((uint64_t*)&forMarshaling->vendorFaultCode, sizeof(uint64_t));
+    vkStream->write((uint64_t*)&forMarshaling->vendorFaultData, sizeof(uint64_t));
+}
+
+void unmarshal_VkDeviceFaultVendorInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkDeviceFaultVendorInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    vkStream->read((uint64_t*)&forUnmarshaling->vendorFaultCode, sizeof(uint64_t));
+    vkStream->read((uint64_t*)&forUnmarshaling->vendorFaultData, sizeof(uint64_t));
+}
+
+void marshal_VkDeviceFaultInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                  const VkDeviceFaultInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pAddressInfos;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pAddressInfos) {
+        marshal_VkDeviceFaultAddressInfoEXT(
+            vkStream, rootType, (VkDeviceFaultAddressInfoEXT*)(forMarshaling->pAddressInfos));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pVendorInfos;
+    vkStream->putBe64(cgen_var_1);
+    if (forMarshaling->pVendorInfos) {
+        marshal_VkDeviceFaultVendorInfoEXT(
+            vkStream, rootType, (VkDeviceFaultVendorInfoEXT*)(forMarshaling->pVendorInfos));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pVendorBinaryData;
+    vkStream->putBe64(cgen_var_2);
+    if (forMarshaling->pVendorBinaryData) {
+        vkStream->write((void*)forMarshaling->pVendorBinaryData, sizeof(uint8_t));
+    }
+}
+
+void unmarshal_VkDeviceFaultInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    VkDeviceFaultInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    // WARNING PTR CHECK
+    forUnmarshaling->pAddressInfos = (VkDeviceFaultAddressInfoEXT*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pAddressInfos) {
+        vkStream->alloc((void**)&forUnmarshaling->pAddressInfos,
+                        sizeof(VkDeviceFaultAddressInfoEXT));
+        unmarshal_VkDeviceFaultAddressInfoEXT(
+            vkStream, rootType, (VkDeviceFaultAddressInfoEXT*)(forUnmarshaling->pAddressInfos));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pVendorInfos = (VkDeviceFaultVendorInfoEXT*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pVendorInfos) {
+        vkStream->alloc((void**)&forUnmarshaling->pVendorInfos, sizeof(VkDeviceFaultVendorInfoEXT));
+        unmarshal_VkDeviceFaultVendorInfoEXT(
+            vkStream, rootType, (VkDeviceFaultVendorInfoEXT*)(forUnmarshaling->pVendorInfos));
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pVendorBinaryData = (void*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pVendorBinaryData) {
+        vkStream->alloc((void**)&forUnmarshaling->pVendorBinaryData, sizeof(uint8_t));
+        vkStream->read((void*)forUnmarshaling->pVendorBinaryData, sizeof(uint8_t));
+    }
+}
+
+void marshal_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDeviceFaultVendorBinaryHeaderVersionOneEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((uint32_t*)&forMarshaling->headerSize, sizeof(uint32_t));
+    vkStream->write((VkDeviceFaultVendorBinaryHeaderVersionEXT*)&forMarshaling->headerVersion,
+                    sizeof(VkDeviceFaultVendorBinaryHeaderVersionEXT));
+    vkStream->write((uint32_t*)&forMarshaling->vendorID, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->deviceID, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->driverVersion, sizeof(uint32_t));
+    vkStream->write((uint8_t*)forMarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
+    vkStream->write((uint32_t*)&forMarshaling->applicationNameOffset, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->applicationVersion, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->engineNameOffset, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->engineVersion, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->apiVersion, sizeof(uint32_t));
+}
+
+void unmarshal_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceFaultVendorBinaryHeaderVersionOneEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((uint32_t*)&forUnmarshaling->headerSize, sizeof(uint32_t));
+    vkStream->read((VkDeviceFaultVendorBinaryHeaderVersionEXT*)&forUnmarshaling->headerVersion,
+                   sizeof(VkDeviceFaultVendorBinaryHeaderVersionEXT));
+    vkStream->read((uint32_t*)&forUnmarshaling->vendorID, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->deviceID, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->driverVersion, sizeof(uint32_t));
+    vkStream->read((uint8_t*)forUnmarshaling->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->applicationNameOffset, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->applicationVersion, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->engineNameOffset, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->engineVersion, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->apiVersion, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+void marshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->rasterizationOrderColorAttachmentAccess,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->rasterizationOrderDepthAttachmentAccess,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->rasterizationOrderStencilAttachmentAccess,
+                    sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->rasterizationOrderColorAttachmentAccess,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->rasterizationOrderDepthAttachmentAccess,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->rasterizationOrderStencilAttachmentAccess,
+                   sizeof(VkBool32));
+}
+
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 void marshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -30347,9 +33694,9 @@ void unmarshal_VkDirectFBSurfaceCreateInfoEXT(VulkanStream* vkStream, VkStructur
 
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-void marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+void marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forMarshaling) {
+    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -30359,9 +33706,9 @@ void marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
     vkStream->write((VkBool32*)&forMarshaling->mutableDescriptorType, sizeof(VkBool32));
 }
 
-void unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+void unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forUnmarshaling) {
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -30383,17 +33730,16 @@ void unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
     vkStream->read((VkBool32*)&forUnmarshaling->mutableDescriptorType, sizeof(VkBool32));
 }
 
-void marshal_VkMutableDescriptorTypeListVALVE(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkMutableDescriptorTypeListVALVE* forMarshaling) {
+void marshal_VkMutableDescriptorTypeListEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkMutableDescriptorTypeListEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((uint32_t*)&forMarshaling->descriptorTypeCount, sizeof(uint32_t));
     vkStream->write((const VkDescriptorType*)forMarshaling->pDescriptorTypes,
                     forMarshaling->descriptorTypeCount * sizeof(const VkDescriptorType));
 }
 
-void unmarshal_VkMutableDescriptorTypeListVALVE(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkMutableDescriptorTypeListVALVE* forUnmarshaling) {
+void unmarshal_VkMutableDescriptorTypeListEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkMutableDescriptorTypeListEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((uint32_t*)&forUnmarshaling->descriptorTypeCount, sizeof(uint32_t));
     vkStream->alloc((void**)&forUnmarshaling->pDescriptorTypes,
@@ -30402,9 +33748,9 @@ void unmarshal_VkMutableDescriptorTypeListVALVE(VulkanStream* vkStream, VkStruct
                    forUnmarshaling->descriptorTypeCount * sizeof(const VkDescriptorType));
 }
 
-void marshal_VkMutableDescriptorTypeCreateInfoVALVE(
+void marshal_VkMutableDescriptorTypeCreateInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkMutableDescriptorTypeCreateInfoVALVE* forMarshaling) {
+    const VkMutableDescriptorTypeCreateInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -30414,18 +33760,17 @@ void marshal_VkMutableDescriptorTypeCreateInfoVALVE(
     vkStream->write((uint32_t*)&forMarshaling->mutableDescriptorTypeListCount, sizeof(uint32_t));
     if (forMarshaling) {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->mutableDescriptorTypeListCount; ++i) {
-            marshal_VkMutableDescriptorTypeListVALVE(
+            marshal_VkMutableDescriptorTypeListEXT(
                 vkStream, rootType,
-                (const VkMutableDescriptorTypeListVALVE*)(forMarshaling
-                                                              ->pMutableDescriptorTypeLists +
-                                                          i));
+                (const VkMutableDescriptorTypeListEXT*)(forMarshaling->pMutableDescriptorTypeLists +
+                                                        i));
         }
     }
 }
 
-void unmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
+void unmarshal_VkMutableDescriptorTypeCreateInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkMutableDescriptorTypeCreateInfoVALVE* forUnmarshaling) {
+    VkMutableDescriptorTypeCreateInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -30447,13 +33792,13 @@ void unmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
     vkStream->read((uint32_t*)&forUnmarshaling->mutableDescriptorTypeListCount, sizeof(uint32_t));
     vkStream->alloc((void**)&forUnmarshaling->pMutableDescriptorTypeLists,
                     forUnmarshaling->mutableDescriptorTypeListCount *
-                        sizeof(const VkMutableDescriptorTypeListVALVE));
+                        sizeof(const VkMutableDescriptorTypeListEXT));
     if (forUnmarshaling) {
         for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->mutableDescriptorTypeListCount; ++i) {
-            unmarshal_VkMutableDescriptorTypeListVALVE(
+            unmarshal_VkMutableDescriptorTypeListEXT(
                 vkStream, rootType,
-                (VkMutableDescriptorTypeListVALVE*)(forUnmarshaling->pMutableDescriptorTypeLists +
-                                                    i));
+                (VkMutableDescriptorTypeListEXT*)(forUnmarshaling->pMutableDescriptorTypeLists +
+                                                  i));
         }
     }
 }
@@ -30628,6 +33973,164 @@ void unmarshal_VkPhysicalDeviceDrmPropertiesEXT(VulkanStream* vkStream, VkStruct
 }
 
 #endif
+#ifdef VK_EXT_device_address_binding_report
+void marshal_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->reportAddressBinding, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->reportAddressBinding, sizeof(VkBool32));
+}
+
+void marshal_VkDeviceAddressBindingCallbackDataEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDeviceAddressBindingCallbackDataEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDeviceAddressBindingFlagsEXT*)&forMarshaling->flags,
+                    sizeof(VkDeviceAddressBindingFlagsEXT));
+    vkStream->write((VkDeviceAddress*)&forMarshaling->baseAddress, sizeof(VkDeviceAddress));
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceAddressBindingTypeEXT*)&forMarshaling->bindingType,
+                    sizeof(VkDeviceAddressBindingTypeEXT));
+}
+
+void unmarshal_VkDeviceAddressBindingCallbackDataEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceAddressBindingCallbackDataEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceAddressBindingFlagsEXT*)&forUnmarshaling->flags,
+                   sizeof(VkDeviceAddressBindingFlagsEXT));
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->baseAddress, sizeof(VkDeviceAddress));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceAddressBindingTypeEXT*)&forUnmarshaling->bindingType,
+                   sizeof(VkDeviceAddressBindingTypeEXT));
+}
+
+#endif
+#ifdef VK_EXT_depth_clip_control
+void marshal_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClipControlFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->depthClipControl, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDepthClipControlFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->depthClipControl, sizeof(VkBool32));
+}
+
+void marshal_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelineViewportDepthClipControlCreateInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->negativeOneToOne, sizeof(VkBool32));
+}
+
+void unmarshal_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineViewportDepthClipControlCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->negativeOneToOne, sizeof(VkBool32));
+}
+
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 void marshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -31259,8 +34762,13 @@ void marshal_VkImageFormatConstraintsInfoFUCHSIA(
                     sizeof(VkImageFormatConstraintsFlagsFUCHSIA));
     vkStream->write((uint64_t*)&forMarshaling->sysmemPixelFormat, sizeof(uint64_t));
     vkStream->write((uint32_t*)&forMarshaling->colorSpaceCount, sizeof(uint32_t));
-    marshal_VkSysmemColorSpaceFUCHSIA(
-        vkStream, rootType, (const VkSysmemColorSpaceFUCHSIA*)(forMarshaling->pColorSpaces));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorSpaceCount; ++i) {
+            marshal_VkSysmemColorSpaceFUCHSIA(
+                vkStream, rootType,
+                (const VkSysmemColorSpaceFUCHSIA*)(forMarshaling->pColorSpaces + i));
+        }
+    }
 }
 
 void unmarshal_VkImageFormatConstraintsInfoFUCHSIA(
@@ -31293,9 +34801,14 @@ void unmarshal_VkImageFormatConstraintsInfoFUCHSIA(
     vkStream->read((uint64_t*)&forUnmarshaling->sysmemPixelFormat, sizeof(uint64_t));
     vkStream->read((uint32_t*)&forUnmarshaling->colorSpaceCount, sizeof(uint32_t));
     vkStream->alloc((void**)&forUnmarshaling->pColorSpaces,
-                    sizeof(const VkSysmemColorSpaceFUCHSIA));
-    unmarshal_VkSysmemColorSpaceFUCHSIA(
-        vkStream, rootType, (VkSysmemColorSpaceFUCHSIA*)(forUnmarshaling->pColorSpaces));
+                    forUnmarshaling->colorSpaceCount * sizeof(const VkSysmemColorSpaceFUCHSIA));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorSpaceCount; ++i) {
+            unmarshal_VkSysmemColorSpaceFUCHSIA(
+                vkStream, rootType,
+                (VkSysmemColorSpaceFUCHSIA*)(forUnmarshaling->pColorSpaces + i));
+        }
+    }
 }
 
 void marshal_VkImageConstraintsInfoFUCHSIA(VulkanStream* vkStream, VkStructureType rootType,
@@ -31601,6 +35114,197 @@ void unmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
 }
 
 #endif
+#ifdef VK_EXT_pipeline_properties
+void marshal_VkPipelinePropertiesIdentifierEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelinePropertiesIdentifierEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint8_t*)forMarshaling->pipelineIdentifier, VK_UUID_SIZE * sizeof(uint8_t));
+}
+
+void unmarshal_VkPipelinePropertiesIdentifierEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelinePropertiesIdentifierEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint8_t*)forUnmarshaling->pipelineIdentifier, VK_UUID_SIZE * sizeof(uint8_t));
+}
+
+void marshal_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePipelinePropertiesFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->pipelinePropertiesIdentifier, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->pipelinePropertiesIdentifier, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+void marshal_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->multisampledRenderToSingleSampled, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->multisampledRenderToSingleSampled,
+                   sizeof(VkBool32));
+}
+
+void marshal_VkSubpassResolvePerformanceQueryEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSubpassResolvePerformanceQueryEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->optimal, sizeof(VkBool32));
+}
+
+void unmarshal_VkSubpassResolvePerformanceQueryEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSubpassResolvePerformanceQueryEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->optimal, sizeof(VkBool32));
+}
+
+void marshal_VkMultisampledRenderToSingleSampledInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkMultisampledRenderToSingleSampledInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->multisampledRenderToSingleSampledEnable,
+                    sizeof(VkBool32));
+    vkStream->write((VkSampleCountFlagBits*)&forMarshaling->rasterizationSamples,
+                    sizeof(VkSampleCountFlagBits));
+}
+
+void unmarshal_VkMultisampledRenderToSingleSampledInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkMultisampledRenderToSingleSampledInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->multisampledRenderToSingleSampledEnable,
+                   sizeof(VkBool32));
+    vkStream->read((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples,
+                   sizeof(VkSampleCountFlagBits));
+}
+
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void marshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -31787,6 +35491,52 @@ void unmarshal_VkPipelineColorWriteCreateInfoEXT(
 }
 
 #endif
+#ifdef VK_EXT_primitives_generated_query
+void marshal_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->primitivesGeneratedQuery, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->primitivesGeneratedQueryWithRasterizerDiscard,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->primitivesGeneratedQueryWithNonZeroStreams,
+                    sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->primitivesGeneratedQuery, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->primitivesGeneratedQueryWithRasterizerDiscard,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->primitivesGeneratedQueryWithNonZeroStreams,
+                   sizeof(VkBool32));
+}
+
+#endif
 #ifdef VK_GOOGLE_gfxstream
 void marshal_VkImportColorBufferGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkImportColorBufferGOOGLE* forMarshaling) {
@@ -31899,21 +35649,23 @@ void unmarshal_VkCreateBlobGOOGLE(VulkanStream* vkStream, VkStructureType rootTy
 
 #endif
 #ifdef VK_EXT_global_priority_query
-void marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+#endif
+#ifdef VK_EXT_image_view_min_lod
+void marshal_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forMarshaling) {
+    const VkPhysicalDeviceImageViewMinLodFeaturesEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((VkBool32*)&forMarshaling->globalPriorityQuery, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->minLod, sizeof(VkBool32));
 }
 
-void unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+void unmarshal_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forUnmarshaling) {
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -31932,26 +35684,22 @@ void unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((VkBool32*)&forUnmarshaling->globalPriorityQuery, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->minLod, sizeof(VkBool32));
 }
 
-void marshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkQueueFamilyGlobalPriorityPropertiesEXT* forMarshaling) {
+void marshal_VkImageViewMinLodCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkImageViewMinLodCreateInfoEXT* forMarshaling) {
     (void)rootType;
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
         rootType = forMarshaling->sType;
     }
     marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
-    vkStream->write((uint32_t*)&forMarshaling->priorityCount, sizeof(uint32_t));
-    vkStream->write((VkQueueGlobalPriorityEXT*)forMarshaling->priorities,
-                    VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT));
+    vkStream->write((float*)&forMarshaling->minLod, sizeof(float));
 }
 
-void unmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkQueueFamilyGlobalPriorityPropertiesEXT* forUnmarshaling) {
+void unmarshal_VkImageViewMinLodCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkImageViewMinLodCreateInfoEXT* forUnmarshaling) {
     (void)rootType;
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -31970,9 +35718,7 @@ void unmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
         *(VkStructureType*)forUnmarshaling->pNext = extType;
         unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
     }
-    vkStream->read((uint32_t*)&forUnmarshaling->priorityCount, sizeof(uint32_t));
-    vkStream->read((VkQueueGlobalPriorityEXT*)forUnmarshaling->priorities,
-                   VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT));
+    vkStream->read((float*)&forUnmarshaling->minLod, sizeof(float));
 }
 
 #endif
@@ -32080,8 +35826,930 @@ void unmarshal_VkMultiDrawIndexedInfoEXT(VulkanStream* vkStream, VkStructureType
 }
 
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+void marshal_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->image2DViewOf3D, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->sampler2DViewOf3D, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->image2DViewOf3D, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->sampler2DViewOf3D, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_EXT_shader_tile_image
+void marshal_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderTileImageFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->shaderTileImageColorReadAccess, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderTileImageDepthReadAccess, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderTileImageStencilReadAccess, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderTileImageFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderTileImageColorReadAccess, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderTileImageDepthReadAccess, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderTileImageStencilReadAccess, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderTileImagePropertiesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->shaderTileImageCoherentReadAccelerated,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderTileImageReadSampleFromPixelRateInvocation,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->shaderTileImageReadFromHelperInvocation,
+                    sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderTileImagePropertiesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderTileImageCoherentReadAccelerated,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderTileImageReadSampleFromPixelRateInvocation,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderTileImageReadFromHelperInvocation,
+                   sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_EXT_opacity_micromap
+void marshal_VkMicromapUsageEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                const VkMicromapUsageEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((uint32_t*)&forMarshaling->count, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->subdivisionLevel, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->format, sizeof(uint32_t));
+}
+
+void unmarshal_VkMicromapUsageEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                  VkMicromapUsageEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((uint32_t*)&forUnmarshaling->count, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->subdivisionLevel, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->format, sizeof(uint32_t));
+}
+
+void marshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                      const VkDeviceOrHostAddressKHR* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
+}
+
+void unmarshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkDeviceOrHostAddressKHR* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
+}
+
+void marshal_VkMicromapBuildInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkMicromapBuildInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkMicromapTypeEXT*)&forMarshaling->type, sizeof(VkMicromapTypeEXT));
+    vkStream->write((VkBuildMicromapFlagsEXT*)&forMarshaling->flags,
+                    sizeof(VkBuildMicromapFlagsEXT));
+    vkStream->write((VkBuildMicromapModeEXT*)&forMarshaling->mode, sizeof(VkBuildMicromapModeEXT));
+    uint64_t cgen_var_0 = (uint64_t)forMarshaling->dstMicromap;
+    vkStream->putBe64(cgen_var_0);
+    vkStream->write((uint32_t*)&forMarshaling->usageCountsCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pUsageCounts;
+    vkStream->putBe64(cgen_var_1);
+    if (forMarshaling->pUsageCounts) {
+        if (forMarshaling) {
+            for (uint32_t i = 0; i < (uint32_t)forMarshaling->usageCountsCount; ++i) {
+                marshal_VkMicromapUsageEXT(
+                    vkStream, rootType,
+                    (const VkMicromapUsageEXT*)(forMarshaling->pUsageCounts + i));
+            }
+        }
+    }
+    marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType,
+                                          (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->data));
+    marshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
+                                     (VkDeviceOrHostAddressKHR*)(&forMarshaling->scratchData));
+    marshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->triangleArray));
+    vkStream->write((VkDeviceSize*)&forMarshaling->triangleArrayStride, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkMicromapBuildInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkMicromapBuildInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkMicromapTypeEXT*)&forUnmarshaling->type, sizeof(VkMicromapTypeEXT));
+    vkStream->read((VkBuildMicromapFlagsEXT*)&forUnmarshaling->flags,
+                   sizeof(VkBuildMicromapFlagsEXT));
+    vkStream->read((VkBuildMicromapModeEXT*)&forUnmarshaling->mode, sizeof(VkBuildMicromapModeEXT));
+    forUnmarshaling->dstMicromap = (VkMicromapEXT)vkStream->getBe64();
+    vkStream->read((uint32_t*)&forUnmarshaling->usageCountsCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pUsageCounts = (const VkMicromapUsageEXT*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pUsageCounts) {
+        vkStream->alloc((void**)&forUnmarshaling->pUsageCounts,
+                        forUnmarshaling->usageCountsCount * sizeof(const VkMicromapUsageEXT));
+        if (forUnmarshaling) {
+            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->usageCountsCount; ++i) {
+                unmarshal_VkMicromapUsageEXT(
+                    vkStream, rootType, (VkMicromapUsageEXT*)(forUnmarshaling->pUsageCounts + i));
+            }
+        }
+    }
+    unmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->data));
+    unmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
+                                       (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->scratchData));
+    unmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->triangleArray));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->triangleArrayStride, sizeof(VkDeviceSize));
+}
+
+void marshal_VkMicromapCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     const VkMicromapCreateInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkMicromapCreateFlagsEXT*)&forMarshaling->createFlags,
+                    sizeof(VkMicromapCreateFlagsEXT));
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+    vkStream->write((VkMicromapTypeEXT*)&forMarshaling->type, sizeof(VkMicromapTypeEXT));
+    vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
+}
+
+void unmarshal_VkMicromapCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkMicromapCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkMicromapCreateFlagsEXT*)&forUnmarshaling->createFlags,
+                   sizeof(VkMicromapCreateFlagsEXT));
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_0,
+                                                       (VkBuffer*)&forUnmarshaling->buffer, 1);
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+    vkStream->read((VkMicromapTypeEXT*)&forUnmarshaling->type, sizeof(VkMicromapTypeEXT));
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
+}
+
+void marshal_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceOpacityMicromapFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->micromap, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->micromapCaptureReplay, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->micromapHostCommands, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->micromap, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->micromapCaptureReplay, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->micromapHostCommands, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceOpacityMicromapPropertiesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->maxOpacity2StateSubdivisionLevel, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxOpacity4StateSubdivisionLevel, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxOpacity2StateSubdivisionLevel, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxOpacity4StateSubdivisionLevel, sizeof(uint32_t));
+}
+
+void marshal_VkMicromapVersionInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      const VkMicromapVersionInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((const uint8_t*)forMarshaling->pVersionData,
+                    2 * VK_UUID_SIZE * sizeof(const uint8_t));
+}
+
+void unmarshal_VkMicromapVersionInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkMicromapVersionInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pVersionData,
+                    2 * VK_UUID_SIZE * sizeof(const uint8_t));
+    vkStream->read((uint8_t*)forUnmarshaling->pVersionData,
+                   2 * VK_UUID_SIZE * sizeof(const uint8_t));
+}
+
+void marshal_VkCopyMicromapToMemoryInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkCopyMicromapToMemoryInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0 = (uint64_t)forMarshaling->src;
+    vkStream->putBe64(cgen_var_0);
+    marshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
+                                     (VkDeviceOrHostAddressKHR*)(&forMarshaling->dst));
+    vkStream->write((VkCopyMicromapModeEXT*)&forMarshaling->mode, sizeof(VkCopyMicromapModeEXT));
+}
+
+void unmarshal_VkCopyMicromapToMemoryInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkCopyMicromapToMemoryInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    forUnmarshaling->src = (VkMicromapEXT)vkStream->getBe64();
+    unmarshal_VkDeviceOrHostAddressKHR(vkStream, rootType,
+                                       (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->dst));
+    vkStream->read((VkCopyMicromapModeEXT*)&forUnmarshaling->mode, sizeof(VkCopyMicromapModeEXT));
+}
+
+void marshal_VkCopyMemoryToMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkCopyMemoryToMicromapInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkDeviceOrHostAddressConstKHR(vkStream, rootType,
+                                          (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->src));
+    uint64_t cgen_var_0 = (uint64_t)forMarshaling->dst;
+    vkStream->putBe64(cgen_var_0);
+    vkStream->write((VkCopyMicromapModeEXT*)&forMarshaling->mode, sizeof(VkCopyMicromapModeEXT));
+}
+
+void unmarshal_VkCopyMemoryToMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkCopyMemoryToMicromapInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->src));
+    forUnmarshaling->dst = (VkMicromapEXT)vkStream->getBe64();
+    vkStream->read((VkCopyMicromapModeEXT*)&forUnmarshaling->mode, sizeof(VkCopyMicromapModeEXT));
+}
+
+void marshal_VkCopyMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                   const VkCopyMicromapInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0 = (uint64_t)forMarshaling->src;
+    vkStream->putBe64(cgen_var_0);
+    uint64_t cgen_var_1 = (uint64_t)forMarshaling->dst;
+    vkStream->putBe64(cgen_var_1);
+    vkStream->write((VkCopyMicromapModeEXT*)&forMarshaling->mode, sizeof(VkCopyMicromapModeEXT));
+}
+
+void unmarshal_VkCopyMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkCopyMicromapInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    forUnmarshaling->src = (VkMicromapEXT)vkStream->getBe64();
+    forUnmarshaling->dst = (VkMicromapEXT)vkStream->getBe64();
+    vkStream->read((VkCopyMicromapModeEXT*)&forUnmarshaling->mode, sizeof(VkCopyMicromapModeEXT));
+}
+
+void marshal_VkMicromapBuildSizesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkMicromapBuildSizesInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDeviceSize*)&forMarshaling->micromapSize, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->buildScratchSize, sizeof(VkDeviceSize));
+    vkStream->write((VkBool32*)&forMarshaling->discardable, sizeof(VkBool32));
+}
+
+void unmarshal_VkMicromapBuildSizesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkMicromapBuildSizesInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->micromapSize, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->buildScratchSize, sizeof(VkDeviceSize));
+    vkStream->read((VkBool32*)&forUnmarshaling->discardable, sizeof(VkBool32));
+}
+
+void marshal_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkAccelerationStructureTrianglesOpacityMicromapEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
+    marshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->indexBuffer));
+    vkStream->write((VkDeviceSize*)&forMarshaling->indexStride, sizeof(VkDeviceSize));
+    vkStream->write((uint32_t*)&forMarshaling->baseTriangle, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->usageCountsCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pUsageCounts;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pUsageCounts) {
+        if (forMarshaling) {
+            for (uint32_t i = 0; i < (uint32_t)forMarshaling->usageCountsCount; ++i) {
+                marshal_VkMicromapUsageEXT(
+                    vkStream, rootType,
+                    (const VkMicromapUsageEXT*)(forMarshaling->pUsageCounts + i));
+            }
+        }
+    }
+    uint64_t cgen_var_1 = (uint64_t)forMarshaling->micromap;
+    vkStream->putBe64(cgen_var_1);
+}
+
+void unmarshal_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkAccelerationStructureTrianglesOpacityMicromapEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
+    unmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->indexBuffer));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->indexStride, sizeof(VkDeviceSize));
+    vkStream->read((uint32_t*)&forUnmarshaling->baseTriangle, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->usageCountsCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pUsageCounts = (const VkMicromapUsageEXT*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pUsageCounts) {
+        vkStream->alloc((void**)&forUnmarshaling->pUsageCounts,
+                        forUnmarshaling->usageCountsCount * sizeof(const VkMicromapUsageEXT));
+        if (forUnmarshaling) {
+            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->usageCountsCount; ++i) {
+                unmarshal_VkMicromapUsageEXT(
+                    vkStream, rootType, (VkMicromapUsageEXT*)(forUnmarshaling->pUsageCounts + i));
+            }
+        }
+    }
+    forUnmarshaling->micromap = (VkMicromapEXT)vkStream->getBe64();
+}
+
+void marshal_VkMicromapTriangleEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                   const VkMicromapTriangleEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((uint32_t*)&forMarshaling->dataOffset, sizeof(uint32_t));
+    vkStream->write((uint16_t*)&forMarshaling->subdivisionLevel, sizeof(uint16_t));
+    vkStream->write((uint16_t*)&forMarshaling->format, sizeof(uint16_t));
+}
+
+void unmarshal_VkMicromapTriangleEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkMicromapTriangleEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((uint32_t*)&forUnmarshaling->dataOffset, sizeof(uint32_t));
+    vkStream->read((uint16_t*)&forUnmarshaling->subdivisionLevel, sizeof(uint16_t));
+    vkStream->read((uint16_t*)&forUnmarshaling->format, sizeof(uint16_t));
+}
+
+#endif
+#ifdef VK_NV_displacement_micromap
+void marshal_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->displacementMicromap, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->displacementMicromap, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->maxDisplacementMicromapSubdivisionLevel,
+                    sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxDisplacementMicromapSubdivisionLevel,
+                   sizeof(uint32_t));
+}
+
+void marshal_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkAccelerationStructureTrianglesDisplacementMicromapNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkFormat*)&forMarshaling->displacementBiasAndScaleFormat, sizeof(VkFormat));
+    vkStream->write((VkFormat*)&forMarshaling->displacementVectorFormat, sizeof(VkFormat));
+    marshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType,
+        (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->displacementBiasAndScaleBuffer));
+    vkStream->write((VkDeviceSize*)&forMarshaling->displacementBiasAndScaleStride,
+                    sizeof(VkDeviceSize));
+    marshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType,
+        (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->displacementVectorBuffer));
+    vkStream->write((VkDeviceSize*)&forMarshaling->displacementVectorStride, sizeof(VkDeviceSize));
+    marshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType,
+        (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->displacedMicromapPrimitiveFlags));
+    vkStream->write((VkDeviceSize*)&forMarshaling->displacedMicromapPrimitiveFlagsStride,
+                    sizeof(VkDeviceSize));
+    vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
+    marshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forMarshaling->indexBuffer));
+    vkStream->write((VkDeviceSize*)&forMarshaling->indexStride, sizeof(VkDeviceSize));
+    vkStream->write((uint32_t*)&forMarshaling->baseTriangle, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->usageCountsCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pUsageCounts;
+    vkStream->putBe64(cgen_var_0);
+    if (forMarshaling->pUsageCounts) {
+        if (forMarshaling) {
+            for (uint32_t i = 0; i < (uint32_t)forMarshaling->usageCountsCount; ++i) {
+                marshal_VkMicromapUsageEXT(
+                    vkStream, rootType,
+                    (const VkMicromapUsageEXT*)(forMarshaling->pUsageCounts + i));
+            }
+        }
+    }
+    uint64_t cgen_var_1 = (uint64_t)forMarshaling->micromap;
+    vkStream->putBe64(cgen_var_1);
+}
+
+void unmarshal_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkAccelerationStructureTrianglesDisplacementMicromapNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkFormat*)&forUnmarshaling->displacementBiasAndScaleFormat, sizeof(VkFormat));
+    vkStream->read((VkFormat*)&forUnmarshaling->displacementVectorFormat, sizeof(VkFormat));
+    unmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType,
+        (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->displacementBiasAndScaleBuffer));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->displacementBiasAndScaleStride,
+                   sizeof(VkDeviceSize));
+    unmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType,
+        (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->displacementVectorBuffer));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->displacementVectorStride, sizeof(VkDeviceSize));
+    unmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType,
+        (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->displacedMicromapPrimitiveFlags));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->displacedMicromapPrimitiveFlagsStride,
+                   sizeof(VkDeviceSize));
+    vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
+    unmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->indexBuffer));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->indexStride, sizeof(VkDeviceSize));
+    vkStream->read((uint32_t*)&forUnmarshaling->baseTriangle, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->usageCountsCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pUsageCounts = (const VkMicromapUsageEXT*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pUsageCounts) {
+        vkStream->alloc((void**)&forUnmarshaling->pUsageCounts,
+                        forUnmarshaling->usageCountsCount * sizeof(const VkMicromapUsageEXT));
+        if (forUnmarshaling) {
+            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->usageCountsCount; ++i) {
+                unmarshal_VkMicromapUsageEXT(
+                    vkStream, rootType, (VkMicromapUsageEXT*)(forUnmarshaling->pUsageCounts + i));
+            }
+        }
+    }
+    forUnmarshaling->micromap = (VkMicromapEXT)vkStream->getBe64();
+}
+
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void marshal_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->clustercullingShader, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->multiviewClusterCullingShader, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->clustercullingShader, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->multiviewClusterCullingShader, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)forMarshaling->maxWorkGroupCount, 3 * sizeof(uint32_t));
+    vkStream->write((uint32_t*)forMarshaling->maxWorkGroupSize, 3 * sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxOutputClusterCount, sizeof(uint32_t));
+    vkStream->write((VkDeviceSize*)&forMarshaling->indirectBufferOffsetAlignment,
+                    sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)forUnmarshaling->maxWorkGroupCount, 3 * sizeof(uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->maxWorkGroupSize, 3 * sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxOutputClusterCount, sizeof(uint32_t));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->indirectBufferOffsetAlignment,
+                   sizeof(VkDeviceSize));
+}
+
+#endif
 #ifdef VK_EXT_border_color_swizzle
 void marshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -32200,19 +36868,2674 @@ void unmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
 }
 
 #endif
-#ifdef VK_KHR_acceleration_structure
-void marshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                      const VkDeviceOrHostAddressKHR* forMarshaling) {
+#ifdef VK_ARM_shader_core_properties
+void marshal_VkPhysicalDeviceShaderCorePropertiesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderCorePropertiesARM* forMarshaling) {
     (void)rootType;
-    vkStream->write((VkDeviceAddress*)&forMarshaling->deviceAddress, sizeof(VkDeviceAddress));
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->pixelRate, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->texelRate, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->fmaRate, sizeof(uint32_t));
 }
 
-void unmarshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                        VkDeviceOrHostAddressKHR* forUnmarshaling) {
+void unmarshal_VkPhysicalDeviceShaderCorePropertiesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderCorePropertiesARM* forUnmarshaling) {
     (void)rootType;
-    vkStream->read((VkDeviceAddress*)&forUnmarshaling->deviceAddress, sizeof(VkDeviceAddress));
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->pixelRate, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->texelRate, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->fmaRate, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+void marshal_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->imageSlicedViewOf3D, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->imageSlicedViewOf3D, sizeof(VkBool32));
+}
+
+void marshal_VkImageViewSlicedCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkImageViewSlicedCreateInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->sliceOffset, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->sliceCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkImageViewSlicedCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkImageViewSlicedCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->sliceOffset, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->sliceCount, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void marshal_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->descriptorSetHostMapping, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->descriptorSetHostMapping, sizeof(VkBool32));
+}
+
+void marshal_VkDescriptorSetBindingReferenceVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDescriptorSetBindingReferenceVALVE* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0;
+    vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(
+        &forMarshaling->descriptorSetLayout, &cgen_var_0, 1);
+    vkStream->write((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->write((uint32_t*)&forMarshaling->binding, sizeof(uint32_t));
+}
+
+void unmarshal_VkDescriptorSetBindingReferenceVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorSetBindingReferenceVALVE* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    uint64_t cgen_var_0;
+    vkStream->read((uint64_t*)&cgen_var_0, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(
+        &cgen_var_0, (VkDescriptorSetLayout*)&forUnmarshaling->descriptorSetLayout, 1);
+    vkStream->read((uint32_t*)&forUnmarshaling->binding, sizeof(uint32_t));
+}
+
+void marshal_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDescriptorSetLayoutHostMappingInfoVALVE* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    uint64_t cgen_var_0 = (uint64_t)forMarshaling->descriptorOffset;
+    vkStream->putBe64(cgen_var_0);
+    vkStream->write((uint32_t*)&forMarshaling->descriptorSize, sizeof(uint32_t));
+}
+
+void unmarshal_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorSetLayoutHostMappingInfoVALVE* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    forUnmarshaling->descriptorOffset = (size_t)vkStream->getBe64();
+    vkStream->read((uint32_t*)&forUnmarshaling->descriptorSize, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+void marshal_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->depthClampZeroOne, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->depthClampZeroOne, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+void marshal_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->nonSeamlessCubeMap, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->nonSeamlessCubeMap, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+void marshal_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->fragmentDensityMapOffset, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->fragmentDensityMapOffset, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkExtent2D(vkStream, rootType,
+                       (VkExtent2D*)(&forMarshaling->fragmentDensityOffsetGranularity));
+}
+
+void unmarshal_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkExtent2D(vkStream, rootType,
+                         (VkExtent2D*)(&forUnmarshaling->fragmentDensityOffsetGranularity));
+}
+
+void marshal_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->fragmentDensityOffsetCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->fragmentDensityOffsetCount; ++i) {
+            marshal_VkOffset2D(vkStream, rootType,
+                               (const VkOffset2D*)(forMarshaling->pFragmentDensityOffsets + i));
+        }
+    }
+}
+
+void unmarshal_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->fragmentDensityOffsetCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pFragmentDensityOffsets,
+                    forUnmarshaling->fragmentDensityOffsetCount * sizeof(const VkOffset2D));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->fragmentDensityOffsetCount; ++i) {
+            unmarshal_VkOffset2D(vkStream, rootType,
+                                 (VkOffset2D*)(forUnmarshaling->pFragmentDensityOffsets + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void marshal_VkCopyMemoryIndirectCommandNV(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkCopyMemoryIndirectCommandNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkDeviceAddress*)&forMarshaling->srcAddress, sizeof(VkDeviceAddress));
+    vkStream->write((VkDeviceAddress*)&forMarshaling->dstAddress, sizeof(VkDeviceAddress));
+    vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
+}
+
+void unmarshal_VkCopyMemoryIndirectCommandNV(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkCopyMemoryIndirectCommandNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->srcAddress, sizeof(VkDeviceAddress));
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->dstAddress, sizeof(VkDeviceAddress));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
+}
+
+void marshal_VkCopyMemoryToImageIndirectCommandNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkCopyMemoryToImageIndirectCommandNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkDeviceAddress*)&forMarshaling->srcAddress, sizeof(VkDeviceAddress));
+    vkStream->write((uint32_t*)&forMarshaling->bufferRowLength, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->bufferImageHeight, sizeof(uint32_t));
+    marshal_VkImageSubresourceLayers(vkStream, rootType,
+                                     (VkImageSubresourceLayers*)(&forMarshaling->imageSubresource));
+    marshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forMarshaling->imageOffset));
+    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->imageExtent));
+}
+
+void unmarshal_VkCopyMemoryToImageIndirectCommandNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkCopyMemoryToImageIndirectCommandNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->srcAddress, sizeof(VkDeviceAddress));
+    vkStream->read((uint32_t*)&forUnmarshaling->bufferRowLength, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->bufferImageHeight, sizeof(uint32_t));
+    unmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource));
+    unmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset));
+    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent));
+}
+
+void marshal_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->indirectCopy, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->indirectCopy, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkQueueFlags*)&forMarshaling->supportedQueues, sizeof(VkQueueFlags));
+}
+
+void unmarshal_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkQueueFlags*)&forUnmarshaling->supportedQueues, sizeof(VkQueueFlags));
+}
+
+#endif
+#ifdef VK_NV_memory_decompression
+void marshal_VkDecompressMemoryRegionNV(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkDecompressMemoryRegionNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkDeviceAddress*)&forMarshaling->srcAddress, sizeof(VkDeviceAddress));
+    vkStream->write((VkDeviceAddress*)&forMarshaling->dstAddress, sizeof(VkDeviceAddress));
+    vkStream->write((VkDeviceSize*)&forMarshaling->compressedSize, sizeof(VkDeviceSize));
+    vkStream->write((VkDeviceSize*)&forMarshaling->decompressedSize, sizeof(VkDeviceSize));
+    vkStream->write((VkMemoryDecompressionMethodFlagsNV*)&forMarshaling->decompressionMethod,
+                    sizeof(VkMemoryDecompressionMethodFlagsNV));
+}
+
+void unmarshal_VkDecompressMemoryRegionNV(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkDecompressMemoryRegionNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->srcAddress, sizeof(VkDeviceAddress));
+    vkStream->read((VkDeviceAddress*)&forUnmarshaling->dstAddress, sizeof(VkDeviceAddress));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->compressedSize, sizeof(VkDeviceSize));
+    vkStream->read((VkDeviceSize*)&forUnmarshaling->decompressedSize, sizeof(VkDeviceSize));
+    vkStream->read((VkMemoryDecompressionMethodFlagsNV*)&forUnmarshaling->decompressionMethod,
+                   sizeof(VkMemoryDecompressionMethodFlagsNV));
+}
+
+void marshal_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMemoryDecompressionFeaturesNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->memoryDecompression, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->memoryDecompression, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkMemoryDecompressionMethodFlagsNV*)&forMarshaling->decompressionMethods,
+                    sizeof(VkMemoryDecompressionMethodFlagsNV));
+    vkStream->write((uint64_t*)&forMarshaling->maxDecompressionIndirectCount, sizeof(uint64_t));
+}
+
+void unmarshal_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkMemoryDecompressionMethodFlagsNV*)&forUnmarshaling->decompressionMethods,
+                   sizeof(VkMemoryDecompressionMethodFlagsNV));
+    vkStream->read((uint64_t*)&forUnmarshaling->maxDecompressionIndirectCount, sizeof(uint64_t));
+}
+
+#endif
+#ifdef VK_NV_linear_color_attachment
+void marshal_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->linearColorAttachment, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->linearColorAttachment, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+void marshal_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->imageCompressionControlSwapchain, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->imageCompressionControlSwapchain, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_QCOM_image_processing
+void marshal_VkImageViewSampleWeightCreateInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkImageViewSampleWeightCreateInfoQCOM* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->filterCenter));
+    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->filterSize));
+    vkStream->write((uint32_t*)&forMarshaling->numPhases, sizeof(uint32_t));
+}
+
+void unmarshal_VkImageViewSampleWeightCreateInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageViewSampleWeightCreateInfoQCOM* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->filterCenter));
+    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->filterSize));
+    vkStream->read((uint32_t*)&forUnmarshaling->numPhases, sizeof(uint32_t));
+}
+
+void marshal_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceImageProcessingFeaturesQCOM* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->textureSampleWeighted, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->textureBoxFilter, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->textureBlockMatch, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageProcessingFeaturesQCOM* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->textureSampleWeighted, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->textureBoxFilter, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->textureBlockMatch, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceImageProcessingPropertiesQCOM* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->maxWeightFilterPhases, sizeof(uint32_t));
+    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxWeightFilterDimension));
+    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxBlockMatchRegion));
+    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->maxBoxFilterBlockSize));
+}
+
+void unmarshal_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageProcessingPropertiesQCOM* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxWeightFilterPhases, sizeof(uint32_t));
+    unmarshal_VkExtent2D(vkStream, rootType,
+                         (VkExtent2D*)(&forUnmarshaling->maxWeightFilterDimension));
+    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxBlockMatchRegion));
+    unmarshal_VkExtent2D(vkStream, rootType,
+                         (VkExtent2D*)(&forUnmarshaling->maxBoxFilterBlockSize));
+}
+
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void marshal_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3TessellationDomainOrigin,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3DepthClampEnable,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3PolygonMode, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3RasterizationSamples,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3SampleMask, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3AlphaToCoverageEnable,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3AlphaToOneEnable,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3LogicOpEnable,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ColorBlendEnable,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ColorBlendEquation,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ColorWriteMask,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3RasterizationStream,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ConservativeRasterizationMode,
+                    sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->extendedDynamicState3ExtraPrimitiveOverestimationSize,
+        sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3DepthClipEnable,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3SampleLocationsEnable,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ColorBlendAdvanced,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ProvokingVertexMode,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3LineRasterizationMode,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3LineStippleEnable,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3DepthClipNegativeOneToOne,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ViewportWScalingEnable,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ViewportSwizzle,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3CoverageToColorEnable,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3CoverageToColorLocation,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3CoverageModulationMode,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3CoverageModulationTableEnable,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3CoverageModulationTable,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3CoverageReductionMode,
+                    sizeof(VkBool32));
+    vkStream->write(
+        (VkBool32*)&forMarshaling->extendedDynamicState3RepresentativeFragmentTestEnable,
+        sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->extendedDynamicState3ShadingRateImageEnable,
+                    sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3TessellationDomainOrigin,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3DepthClampEnable,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3PolygonMode, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3RasterizationSamples,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3SampleMask, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3AlphaToCoverageEnable,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3AlphaToOneEnable,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3LogicOpEnable,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ColorBlendEnable,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ColorBlendEquation,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ColorWriteMask,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3RasterizationStream,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ConservativeRasterizationMode,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->extendedDynamicState3ExtraPrimitiveOverestimationSize,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3DepthClipEnable,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3SampleLocationsEnable,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ColorBlendAdvanced,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ProvokingVertexMode,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3LineRasterizationMode,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3LineStippleEnable,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3DepthClipNegativeOneToOne,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ViewportWScalingEnable,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ViewportSwizzle,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageToColorEnable,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageToColorLocation,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageModulationMode,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageModulationTableEnable,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageModulationTable,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageReductionMode,
+                   sizeof(VkBool32));
+    vkStream->read(
+        (VkBool32*)&forUnmarshaling->extendedDynamicState3RepresentativeFragmentTestEnable,
+        sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->extendedDynamicState3ShadingRateImageEnable,
+                   sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->dynamicPrimitiveTopologyUnrestricted,
+                    sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->dynamicPrimitiveTopologyUnrestricted,
+                   sizeof(VkBool32));
+}
+
+void marshal_VkColorBlendEquationEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     const VkColorBlendEquationEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkBlendFactor*)&forMarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
+    vkStream->write((VkBlendFactor*)&forMarshaling->dstColorBlendFactor, sizeof(VkBlendFactor));
+    vkStream->write((VkBlendOp*)&forMarshaling->colorBlendOp, sizeof(VkBlendOp));
+    vkStream->write((VkBlendFactor*)&forMarshaling->srcAlphaBlendFactor, sizeof(VkBlendFactor));
+    vkStream->write((VkBlendFactor*)&forMarshaling->dstAlphaBlendFactor, sizeof(VkBlendFactor));
+    vkStream->write((VkBlendOp*)&forMarshaling->alphaBlendOp, sizeof(VkBlendOp));
+}
+
+void unmarshal_VkColorBlendEquationEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkColorBlendEquationEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkBlendFactor*)&forUnmarshaling->srcColorBlendFactor, sizeof(VkBlendFactor));
+    vkStream->read((VkBlendFactor*)&forUnmarshaling->dstColorBlendFactor, sizeof(VkBlendFactor));
+    vkStream->read((VkBlendOp*)&forUnmarshaling->colorBlendOp, sizeof(VkBlendOp));
+    vkStream->read((VkBlendFactor*)&forUnmarshaling->srcAlphaBlendFactor, sizeof(VkBlendFactor));
+    vkStream->read((VkBlendFactor*)&forUnmarshaling->dstAlphaBlendFactor, sizeof(VkBlendFactor));
+    vkStream->read((VkBlendOp*)&forUnmarshaling->alphaBlendOp, sizeof(VkBlendOp));
+}
+
+void marshal_VkColorBlendAdvancedEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     const VkColorBlendAdvancedEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkBlendOp*)&forMarshaling->advancedBlendOp, sizeof(VkBlendOp));
+    vkStream->write((VkBool32*)&forMarshaling->srcPremultiplied, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->dstPremultiplied, sizeof(VkBool32));
+    vkStream->write((VkBlendOverlapEXT*)&forMarshaling->blendOverlap, sizeof(VkBlendOverlapEXT));
+    vkStream->write((VkBool32*)&forMarshaling->clampResults, sizeof(VkBool32));
+}
+
+void unmarshal_VkColorBlendAdvancedEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkColorBlendAdvancedEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkBlendOp*)&forUnmarshaling->advancedBlendOp, sizeof(VkBlendOp));
+    vkStream->read((VkBool32*)&forUnmarshaling->srcPremultiplied, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->dstPremultiplied, sizeof(VkBool32));
+    vkStream->read((VkBlendOverlapEXT*)&forUnmarshaling->blendOverlap, sizeof(VkBlendOverlapEXT));
+    vkStream->read((VkBool32*)&forUnmarshaling->clampResults, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+void marshal_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->subpassMergeFeedback, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->subpassMergeFeedback, sizeof(VkBool32));
+}
+
+void marshal_VkRenderPassCreationControlEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkRenderPassCreationControlEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->disallowMerging, sizeof(VkBool32));
+}
+
+void unmarshal_VkRenderPassCreationControlEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkRenderPassCreationControlEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->disallowMerging, sizeof(VkBool32));
+}
+
+void marshal_VkRenderPassCreationFeedbackInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkRenderPassCreationFeedbackInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((uint32_t*)&forMarshaling->postMergeSubpassCount, sizeof(uint32_t));
+}
+
+void unmarshal_VkRenderPassCreationFeedbackInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassCreationFeedbackInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((uint32_t*)&forUnmarshaling->postMergeSubpassCount, sizeof(uint32_t));
+}
+
+void marshal_VkRenderPassCreationFeedbackCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkRenderPassCreationFeedbackCreateInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkRenderPassCreationFeedbackInfoEXT(
+        vkStream, rootType,
+        (VkRenderPassCreationFeedbackInfoEXT*)(forMarshaling->pRenderPassFeedback));
+}
+
+void unmarshal_VkRenderPassCreationFeedbackCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassCreationFeedbackCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pRenderPassFeedback,
+                    sizeof(VkRenderPassCreationFeedbackInfoEXT));
+    unmarshal_VkRenderPassCreationFeedbackInfoEXT(
+        vkStream, rootType,
+        (VkRenderPassCreationFeedbackInfoEXT*)(forUnmarshaling->pRenderPassFeedback));
+}
+
+void marshal_VkRenderPassSubpassFeedbackInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkRenderPassSubpassFeedbackInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkSubpassMergeStatusEXT*)&forMarshaling->subpassMergeStatus,
+                    sizeof(VkSubpassMergeStatusEXT));
+    vkStream->write((char*)forMarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    vkStream->write((uint32_t*)&forMarshaling->postMergeIndex, sizeof(uint32_t));
+}
+
+void unmarshal_VkRenderPassSubpassFeedbackInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassSubpassFeedbackInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkSubpassMergeStatusEXT*)&forUnmarshaling->subpassMergeStatus,
+                   sizeof(VkSubpassMergeStatusEXT));
+    vkStream->read((char*)forUnmarshaling->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    vkStream->read((uint32_t*)&forUnmarshaling->postMergeIndex, sizeof(uint32_t));
+}
+
+void marshal_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkRenderPassSubpassFeedbackCreateInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkRenderPassSubpassFeedbackInfoEXT(
+        vkStream, rootType, (VkRenderPassSubpassFeedbackInfoEXT*)(forMarshaling->pSubpassFeedback));
+}
+
+void unmarshal_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassSubpassFeedbackCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pSubpassFeedback,
+                    sizeof(VkRenderPassSubpassFeedbackInfoEXT));
+    unmarshal_VkRenderPassSubpassFeedbackInfoEXT(
+        vkStream, rootType,
+        (VkRenderPassSubpassFeedbackInfoEXT*)(forUnmarshaling->pSubpassFeedback));
+}
+
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+void marshal_VkDirectDriverLoadingInfoLUNARG(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkDirectDriverLoadingInfoLUNARG* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDirectDriverLoadingFlagsLUNARG*)&forMarshaling->flags,
+                    sizeof(VkDirectDriverLoadingFlagsLUNARG));
+    uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnGetInstanceProcAddr;
+    vkStream->putBe64(cgen_var_0);
+}
+
+void unmarshal_VkDirectDriverLoadingInfoLUNARG(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkDirectDriverLoadingInfoLUNARG* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDirectDriverLoadingFlagsLUNARG*)&forUnmarshaling->flags,
+                   sizeof(VkDirectDriverLoadingFlagsLUNARG));
+    forUnmarshaling->pfnGetInstanceProcAddr = (PFN_vkGetInstanceProcAddrLUNARG)vkStream->getBe64();
+}
+
+void marshal_VkDirectDriverLoadingListLUNARG(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkDirectDriverLoadingListLUNARG* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkDirectDriverLoadingModeLUNARG*)&forMarshaling->mode,
+                    sizeof(VkDirectDriverLoadingModeLUNARG));
+    vkStream->write((uint32_t*)&forMarshaling->driverCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->driverCount; ++i) {
+            marshal_VkDirectDriverLoadingInfoLUNARG(
+                vkStream, rootType,
+                (const VkDirectDriverLoadingInfoLUNARG*)(forMarshaling->pDrivers + i));
+        }
+    }
+}
+
+void unmarshal_VkDirectDriverLoadingListLUNARG(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkDirectDriverLoadingListLUNARG* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkDirectDriverLoadingModeLUNARG*)&forUnmarshaling->mode,
+                   sizeof(VkDirectDriverLoadingModeLUNARG));
+    vkStream->read((uint32_t*)&forUnmarshaling->driverCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pDrivers,
+                    forUnmarshaling->driverCount * sizeof(const VkDirectDriverLoadingInfoLUNARG));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->driverCount; ++i) {
+            unmarshal_VkDirectDriverLoadingInfoLUNARG(
+                vkStream, rootType,
+                (VkDirectDriverLoadingInfoLUNARG*)(forUnmarshaling->pDrivers + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void marshal_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->shaderModuleIdentifier, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderModuleIdentifier, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint8_t*)forMarshaling->shaderModuleIdentifierAlgorithmUUID,
+                    VK_UUID_SIZE * sizeof(uint8_t));
+}
+
+void unmarshal_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint8_t*)forUnmarshaling->shaderModuleIdentifierAlgorithmUUID,
+                   VK_UUID_SIZE * sizeof(uint8_t));
+}
+
+void marshal_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->identifierSize, sizeof(uint32_t));
+    vkStream->write((const uint8_t*)forMarshaling->pIdentifier,
+                    forMarshaling->identifierSize * sizeof(const uint8_t));
+}
+
+void unmarshal_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->identifierSize, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pIdentifier,
+                    forUnmarshaling->identifierSize * sizeof(const uint8_t));
+    vkStream->read((uint8_t*)forUnmarshaling->pIdentifier,
+                   forUnmarshaling->identifierSize * sizeof(const uint8_t));
+}
+
+void marshal_VkShaderModuleIdentifierEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkShaderModuleIdentifierEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->identifierSize, sizeof(uint32_t));
+    vkStream->write((uint8_t*)forMarshaling->identifier,
+                    VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t));
+}
+
+void unmarshal_VkShaderModuleIdentifierEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkShaderModuleIdentifierEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->identifierSize, sizeof(uint32_t));
+    vkStream->read((uint8_t*)forUnmarshaling->identifier,
+                   VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t));
+}
+
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+void marshal_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceOpticalFlowFeaturesNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->opticalFlow, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpticalFlowFeaturesNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->opticalFlow, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceOpticalFlowPropertiesNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkOpticalFlowGridSizeFlagsNV*)&forMarshaling->supportedOutputGridSizes,
+                    sizeof(VkOpticalFlowGridSizeFlagsNV));
+    vkStream->write((VkOpticalFlowGridSizeFlagsNV*)&forMarshaling->supportedHintGridSizes,
+                    sizeof(VkOpticalFlowGridSizeFlagsNV));
+    vkStream->write((VkBool32*)&forMarshaling->hintSupported, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->costSupported, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->bidirectionalFlowSupported, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->globalFlowSupported, sizeof(VkBool32));
+    vkStream->write((uint32_t*)&forMarshaling->minWidth, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->minHeight, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxWidth, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxHeight, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxNumRegionsOfInterest, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpticalFlowPropertiesNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkOpticalFlowGridSizeFlagsNV*)&forUnmarshaling->supportedOutputGridSizes,
+                   sizeof(VkOpticalFlowGridSizeFlagsNV));
+    vkStream->read((VkOpticalFlowGridSizeFlagsNV*)&forUnmarshaling->supportedHintGridSizes,
+                   sizeof(VkOpticalFlowGridSizeFlagsNV));
+    vkStream->read((VkBool32*)&forUnmarshaling->hintSupported, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->costSupported, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->bidirectionalFlowSupported, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->globalFlowSupported, sizeof(VkBool32));
+    vkStream->read((uint32_t*)&forUnmarshaling->minWidth, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->minHeight, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxWidth, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxHeight, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxNumRegionsOfInterest, sizeof(uint32_t));
+}
+
+void marshal_VkOpticalFlowImageFormatInfoNV(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkOpticalFlowImageFormatInfoNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkOpticalFlowUsageFlagsNV*)&forMarshaling->usage,
+                    sizeof(VkOpticalFlowUsageFlagsNV));
+}
+
+void unmarshal_VkOpticalFlowImageFormatInfoNV(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkOpticalFlowImageFormatInfoNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkOpticalFlowUsageFlagsNV*)&forUnmarshaling->usage,
+                   sizeof(VkOpticalFlowUsageFlagsNV));
+}
+
+void marshal_VkOpticalFlowImageFormatPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkOpticalFlowImageFormatPropertiesNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkFormat*)&forMarshaling->format, sizeof(VkFormat));
+}
+
+void unmarshal_VkOpticalFlowImageFormatPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpticalFlowImageFormatPropertiesNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkFormat*)&forUnmarshaling->format, sizeof(VkFormat));
+}
+
+void marshal_VkOpticalFlowSessionCreateInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkOpticalFlowSessionCreateInfoNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
+    vkStream->write((VkFormat*)&forMarshaling->imageFormat, sizeof(VkFormat));
+    vkStream->write((VkFormat*)&forMarshaling->flowVectorFormat, sizeof(VkFormat));
+    vkStream->write((VkFormat*)&forMarshaling->costFormat, sizeof(VkFormat));
+    vkStream->write((VkOpticalFlowGridSizeFlagsNV*)&forMarshaling->outputGridSize,
+                    sizeof(VkOpticalFlowGridSizeFlagsNV));
+    vkStream->write((VkOpticalFlowGridSizeFlagsNV*)&forMarshaling->hintGridSize,
+                    sizeof(VkOpticalFlowGridSizeFlagsNV));
+    vkStream->write((VkOpticalFlowPerformanceLevelNV*)&forMarshaling->performanceLevel,
+                    sizeof(VkOpticalFlowPerformanceLevelNV));
+    vkStream->write((VkOpticalFlowSessionCreateFlagsNV*)&forMarshaling->flags,
+                    sizeof(VkOpticalFlowSessionCreateFlagsNV));
+}
+
+void unmarshal_VkOpticalFlowSessionCreateInfoNV(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkOpticalFlowSessionCreateInfoNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
+    vkStream->read((VkFormat*)&forUnmarshaling->imageFormat, sizeof(VkFormat));
+    vkStream->read((VkFormat*)&forUnmarshaling->flowVectorFormat, sizeof(VkFormat));
+    vkStream->read((VkFormat*)&forUnmarshaling->costFormat, sizeof(VkFormat));
+    vkStream->read((VkOpticalFlowGridSizeFlagsNV*)&forUnmarshaling->outputGridSize,
+                   sizeof(VkOpticalFlowGridSizeFlagsNV));
+    vkStream->read((VkOpticalFlowGridSizeFlagsNV*)&forUnmarshaling->hintGridSize,
+                   sizeof(VkOpticalFlowGridSizeFlagsNV));
+    vkStream->read((VkOpticalFlowPerformanceLevelNV*)&forUnmarshaling->performanceLevel,
+                   sizeof(VkOpticalFlowPerformanceLevelNV));
+    vkStream->read((VkOpticalFlowSessionCreateFlagsNV*)&forUnmarshaling->flags,
+                   sizeof(VkOpticalFlowSessionCreateFlagsNV));
+}
+
+void marshal_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkOpticalFlowSessionCreatePrivateDataInfoNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->id, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->size, sizeof(uint32_t));
+    vkStream->write((const void*)forMarshaling->pPrivateData, sizeof(const uint8_t));
+}
+
+void unmarshal_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpticalFlowSessionCreatePrivateDataInfoNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->id, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->size, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pPrivateData, sizeof(const uint8_t));
+    vkStream->read((void*)forUnmarshaling->pPrivateData, sizeof(const uint8_t));
+}
+
+void marshal_VkOpticalFlowExecuteInfoNV(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkOpticalFlowExecuteInfoNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkOpticalFlowExecuteFlagsNV*)&forMarshaling->flags,
+                    sizeof(VkOpticalFlowExecuteFlagsNV));
+    vkStream->write((uint32_t*)&forMarshaling->regionCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->regionCount; ++i) {
+            marshal_VkRect2D(vkStream, rootType, (const VkRect2D*)(forMarshaling->pRegions + i));
+        }
+    }
+}
+
+void unmarshal_VkOpticalFlowExecuteInfoNV(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkOpticalFlowExecuteInfoNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkOpticalFlowExecuteFlagsNV*)&forUnmarshaling->flags,
+                   sizeof(VkOpticalFlowExecuteFlagsNV));
+    vkStream->read((uint32_t*)&forUnmarshaling->regionCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkRect2D));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+            unmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pRegions + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_legacy_dithering
+void marshal_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceLegacyDitheringFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->legacyDithering, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->legacyDithering, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+void marshal_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->pipelineProtectedAccess, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->pipelineProtectedAccess, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_EXT_shader_object
+void marshal_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderObjectFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->shaderObject, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderObjectFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderObject, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderObjectPropertiesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint8_t*)forMarshaling->shaderBinaryUUID, VK_UUID_SIZE * sizeof(uint8_t));
+    vkStream->write((uint32_t*)&forMarshaling->shaderBinaryVersion, sizeof(uint32_t));
 }
 
+void unmarshal_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderObjectPropertiesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint8_t*)forUnmarshaling->shaderBinaryUUID, VK_UUID_SIZE * sizeof(uint8_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->shaderBinaryVersion, sizeof(uint32_t));
+}
+
+void marshal_VkShaderCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                   const VkShaderCreateInfoEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkShaderCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkShaderCreateFlagsEXT));
+    vkStream->write((VkShaderStageFlagBits*)&forMarshaling->stage, sizeof(VkShaderStageFlagBits));
+    vkStream->write((VkShaderStageFlags*)&forMarshaling->nextStage, sizeof(VkShaderStageFlags));
+    vkStream->write((VkShaderCodeTypeEXT*)&forMarshaling->codeType, sizeof(VkShaderCodeTypeEXT));
+    uint64_t cgen_var_0 = (uint64_t)forMarshaling->codeSize;
+    vkStream->putBe64(cgen_var_0);
+    vkStream->write((const void*)forMarshaling->pCode,
+                    forMarshaling->codeSize * sizeof(const uint8_t));
+    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
+        // WARNING PTR CHECK
+        uint64_t cgen_var_0_0 = (uint64_t)(uintptr_t)forMarshaling->pName;
+        vkStream->putBe64(cgen_var_0_0);
+        if (forMarshaling->pName) {
+            vkStream->putString(forMarshaling->pName);
+        }
+    } else {
+        vkStream->putString(forMarshaling->pName);
+    }
+    vkStream->write((uint32_t*)&forMarshaling->setLayoutCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pSetLayouts;
+    vkStream->putBe64(cgen_var_1);
+    if (forMarshaling->pSetLayouts) {
+        if (forMarshaling->setLayoutCount) {
+            uint64_t* cgen_var_1_0;
+            vkStream->alloc((void**)&cgen_var_1_0, forMarshaling->setLayoutCount * 8);
+            vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(
+                forMarshaling->pSetLayouts, cgen_var_1_0, forMarshaling->setLayoutCount);
+            vkStream->write((uint64_t*)cgen_var_1_0, forMarshaling->setLayoutCount * 8);
+        }
+    }
+    vkStream->write((uint32_t*)&forMarshaling->pushConstantRangeCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    uint64_t cgen_var_2 = (uint64_t)(uintptr_t)forMarshaling->pPushConstantRanges;
+    vkStream->putBe64(cgen_var_2);
+    if (forMarshaling->pPushConstantRanges) {
+        if (forMarshaling) {
+            for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i) {
+                marshal_VkPushConstantRange(
+                    vkStream, rootType,
+                    (const VkPushConstantRange*)(forMarshaling->pPushConstantRanges + i));
+            }
+        }
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_3 = (uint64_t)(uintptr_t)forMarshaling->pSpecializationInfo;
+    vkStream->putBe64(cgen_var_3);
+    if (forMarshaling->pSpecializationInfo) {
+        marshal_VkSpecializationInfo(
+            vkStream, rootType, (const VkSpecializationInfo*)(forMarshaling->pSpecializationInfo));
+    }
+}
+
+void unmarshal_VkShaderCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkShaderCreateInfoEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkShaderCreateFlagsEXT*)&forUnmarshaling->flags,
+                   sizeof(VkShaderCreateFlagsEXT));
+    vkStream->read((VkShaderStageFlagBits*)&forUnmarshaling->stage, sizeof(VkShaderStageFlagBits));
+    vkStream->read((VkShaderStageFlags*)&forUnmarshaling->nextStage, sizeof(VkShaderStageFlags));
+    vkStream->read((VkShaderCodeTypeEXT*)&forUnmarshaling->codeType, sizeof(VkShaderCodeTypeEXT));
+    forUnmarshaling->codeSize = (size_t)vkStream->getBe64();
+    vkStream->alloc((void**)&forUnmarshaling->pCode,
+                    forUnmarshaling->codeSize * sizeof(const uint8_t));
+    vkStream->read((void*)forUnmarshaling->pCode,
+                   forUnmarshaling->codeSize * sizeof(const uint8_t));
+    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
+        // WARNING PTR CHECK
+        forUnmarshaling->pName = (const char*)(uintptr_t)vkStream->getBe64();
+        if (forUnmarshaling->pName) {
+            vkStream->loadStringInPlace((char**)&forUnmarshaling->pName);
+        }
+    } else {
+        vkStream->loadStringInPlace((char**)&forUnmarshaling->pName);
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->setLayoutCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pSetLayouts = (const VkDescriptorSetLayout*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pSetLayouts) {
+        vkStream->alloc((void**)&forUnmarshaling->pSetLayouts,
+                        forUnmarshaling->setLayoutCount * sizeof(const VkDescriptorSetLayout));
+        if (forUnmarshaling->setLayoutCount) {
+            uint64_t* cgen_var_1_0;
+            vkStream->alloc((void**)&cgen_var_1_0, forUnmarshaling->setLayoutCount * 8);
+            vkStream->read((uint64_t*)cgen_var_1_0, forUnmarshaling->setLayoutCount * 8);
+            vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(
+                cgen_var_1_0, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts,
+                forUnmarshaling->setLayoutCount);
+        }
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->pushConstantRangeCount, sizeof(uint32_t));
+    // WARNING PTR CHECK
+    forUnmarshaling->pPushConstantRanges =
+        (const VkPushConstantRange*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pPushConstantRanges) {
+        vkStream->alloc(
+            (void**)&forUnmarshaling->pPushConstantRanges,
+            forUnmarshaling->pushConstantRangeCount * sizeof(const VkPushConstantRange));
+        if (forUnmarshaling) {
+            for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pushConstantRangeCount; ++i) {
+                unmarshal_VkPushConstantRange(
+                    vkStream, rootType,
+                    (VkPushConstantRange*)(forUnmarshaling->pPushConstantRanges + i));
+            }
+        }
+    }
+    // WARNING PTR CHECK
+    forUnmarshaling->pSpecializationInfo =
+        (const VkSpecializationInfo*)(uintptr_t)vkStream->getBe64();
+    if (forUnmarshaling->pSpecializationInfo) {
+        vkStream->alloc((void**)&forUnmarshaling->pSpecializationInfo,
+                        sizeof(const VkSpecializationInfo));
+        unmarshal_VkSpecializationInfo(
+            vkStream, rootType, (VkSpecializationInfo*)(forUnmarshaling->pSpecializationInfo));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_tile_properties
+void marshal_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceTilePropertiesFeaturesQCOM* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->tileProperties, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceTilePropertiesFeaturesQCOM* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->tileProperties, sizeof(VkBool32));
+}
+
+void marshal_VkTilePropertiesQCOM(VulkanStream* vkStream, VkStructureType rootType,
+                                  const VkTilePropertiesQCOM* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    marshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forMarshaling->tileSize));
+    marshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forMarshaling->apronSize));
+    marshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forMarshaling->origin));
+}
+
+void unmarshal_VkTilePropertiesQCOM(VulkanStream* vkStream, VkStructureType rootType,
+                                    VkTilePropertiesQCOM* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    unmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->tileSize));
+    unmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->apronSize));
+    unmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->origin));
+}
+
+#endif
+#ifdef VK_SEC_amigo_profiling
+void marshal_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceAmigoProfilingFeaturesSEC* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->amigoProfiling, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAmigoProfilingFeaturesSEC* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->amigoProfiling, sizeof(VkBool32));
+}
+
+void marshal_VkAmigoProfilingSubmitInfoSEC(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkAmigoProfilingSubmitInfoSEC* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint64_t*)&forMarshaling->firstDrawTimestamp, sizeof(uint64_t));
+    vkStream->write((uint64_t*)&forMarshaling->swapBufferTimestamp, sizeof(uint64_t));
+}
+
+void unmarshal_VkAmigoProfilingSubmitInfoSEC(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkAmigoProfilingSubmitInfoSEC* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint64_t*)&forUnmarshaling->firstDrawTimestamp, sizeof(uint64_t));
+    vkStream->read((uint64_t*)&forUnmarshaling->swapBufferTimestamp, sizeof(uint64_t));
+}
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+void marshal_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->multiviewPerViewViewports, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->multiviewPerViewViewports, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+void marshal_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkRayTracingInvocationReorderModeNV*)&forMarshaling
+                        ->rayTracingInvocationReorderReorderingHint,
+                    sizeof(VkRayTracingInvocationReorderModeNV));
+}
+
+void unmarshal_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkRayTracingInvocationReorderModeNV*)&forUnmarshaling
+                       ->rayTracingInvocationReorderReorderingHint,
+                   sizeof(VkRayTracingInvocationReorderModeNV));
+}
+
+void marshal_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->rayTracingInvocationReorder, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->rayTracingInvocationReorder, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+void marshal_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->shaderCoreBuiltins, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->shaderCoreBuiltins, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint64_t*)&forMarshaling->shaderCoreMask, sizeof(uint64_t));
+    vkStream->write((uint32_t*)&forMarshaling->shaderCoreCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->shaderWarpsPerCore, sizeof(uint32_t));
+}
+
+void unmarshal_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint64_t*)&forUnmarshaling->shaderCoreMask, sizeof(uint64_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->shaderCoreCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->shaderWarpsPerCore, sizeof(uint32_t));
+}
+
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+void marshal_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->pipelineLibraryGroupHandles, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->pipelineLibraryGroupHandles, sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+void marshal_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->multiviewPerViewRenderAreas, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->multiviewPerViewRenderAreas, sizeof(VkBool32));
+}
+
+void marshal_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->perViewRenderAreaCount, sizeof(uint32_t));
+    if (forMarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forMarshaling->perViewRenderAreaCount; ++i) {
+            marshal_VkRect2D(vkStream, rootType,
+                             (const VkRect2D*)(forMarshaling->pPerViewRenderAreas + i));
+        }
+    }
+}
+
+void unmarshal_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->perViewRenderAreaCount, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pPerViewRenderAreas,
+                    forUnmarshaling->perViewRenderAreaCount * sizeof(const VkRect2D));
+    if (forUnmarshaling) {
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->perViewRenderAreaCount; ++i) {
+            unmarshal_VkRect2D(vkStream, rootType,
+                               (VkRect2D*)(forUnmarshaling->pPerViewRenderAreas + i));
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+void marshal_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->attachmentFeedbackLoopDynamicState,
+                    sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->attachmentFeedbackLoopDynamicState,
+                   sizeof(VkBool32));
+}
+
+#endif
+#ifdef VK_KHR_acceleration_structure
 void marshal_VkAccelerationStructureBuildRangeInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
     const VkAccelerationStructureBuildRangeInfoKHR* forMarshaling) {
@@ -33459,6 +40782,174 @@ void unmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
 }
 
 #endif
+#ifdef VK_EXT_mesh_shader
+void marshal_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMeshShaderFeaturesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((VkBool32*)&forMarshaling->taskShader, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->meshShader, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->multiviewMeshShader, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->primitiveFragmentShadingRateMeshShader,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->meshShaderQueries, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMeshShaderFeaturesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((VkBool32*)&forUnmarshaling->taskShader, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->meshShader, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->multiviewMeshShader, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->primitiveFragmentShadingRateMeshShader,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->meshShaderQueries, sizeof(VkBool32));
+}
+
+void marshal_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMeshShaderPropertiesEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forMarshaling->sType;
+    }
+    marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+    vkStream->write((uint32_t*)&forMarshaling->maxTaskWorkGroupTotalCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)forMarshaling->maxTaskWorkGroupCount, 3 * sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTaskWorkGroupInvocations, sizeof(uint32_t));
+    vkStream->write((uint32_t*)forMarshaling->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTaskPayloadSize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTaskSharedMemorySize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxTaskPayloadAndSharedMemorySize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMeshWorkGroupTotalCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)forMarshaling->maxMeshWorkGroupCount, 3 * sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMeshWorkGroupInvocations, sizeof(uint32_t));
+    vkStream->write((uint32_t*)forMarshaling->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMeshSharedMemorySize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMeshPayloadAndSharedMemorySize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMeshOutputMemorySize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMeshPayloadAndOutputMemorySize, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMeshOutputComponents, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMeshOutputVertices, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMeshOutputPrimitives, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMeshOutputLayers, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxMeshMultiviewViewCount, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->meshOutputPerVertexGranularity, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->meshOutputPerPrimitiveGranularity, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPreferredTaskWorkGroupInvocations,
+                    sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->maxPreferredMeshWorkGroupInvocations,
+                    sizeof(uint32_t));
+    vkStream->write((VkBool32*)&forMarshaling->prefersLocalInvocationVertexOutput,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->prefersLocalInvocationPrimitiveOutput,
+                    sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->prefersCompactVertexOutput, sizeof(VkBool32));
+    vkStream->write((VkBool32*)&forMarshaling->prefersCompactPrimitiveOutput, sizeof(VkBool32));
+}
+
+void unmarshal_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMeshShaderPropertiesEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    size_t pNext_size;
+    pNext_size = vkStream->getBe32();
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+    }
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTaskWorkGroupTotalCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->maxTaskWorkGroupCount, 3 * sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTaskWorkGroupInvocations, sizeof(uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->maxTaskWorkGroupSize, 3 * sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTaskPayloadSize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTaskSharedMemorySize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxTaskPayloadAndSharedMemorySize,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshWorkGroupTotalCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->maxMeshWorkGroupCount, 3 * sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshWorkGroupInvocations, sizeof(uint32_t));
+    vkStream->read((uint32_t*)forUnmarshaling->maxMeshWorkGroupSize, 3 * sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshSharedMemorySize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshPayloadAndSharedMemorySize,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshOutputMemorySize, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshPayloadAndOutputMemorySize,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshOutputComponents, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshOutputVertices, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshOutputPrimitives, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshOutputLayers, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxMeshMultiviewViewCount, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->meshOutputPerVertexGranularity, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->meshOutputPerPrimitiveGranularity,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPreferredTaskWorkGroupInvocations,
+                   sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->maxPreferredMeshWorkGroupInvocations,
+                   sizeof(uint32_t));
+    vkStream->read((VkBool32*)&forUnmarshaling->prefersLocalInvocationVertexOutput,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->prefersLocalInvocationPrimitiveOutput,
+                   sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->prefersCompactVertexOutput, sizeof(VkBool32));
+    vkStream->read((VkBool32*)&forUnmarshaling->prefersCompactPrimitiveOutput, sizeof(VkBool32));
+}
+
+void marshal_VkDrawMeshTasksIndirectCommandEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDrawMeshTasksIndirectCommandEXT* forMarshaling) {
+    (void)rootType;
+    vkStream->write((uint32_t*)&forMarshaling->groupCountX, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->groupCountY, sizeof(uint32_t));
+    vkStream->write((uint32_t*)&forMarshaling->groupCountZ, sizeof(uint32_t));
+}
+
+void unmarshal_VkDrawMeshTasksIndirectCommandEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDrawMeshTasksIndirectCommandEXT* forUnmarshaling) {
+    (void)rootType;
+    vkStream->read((uint32_t*)&forUnmarshaling->groupCountX, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->groupCountY, sizeof(uint32_t));
+    vkStream->read((uint32_t*)&forUnmarshaling->groupCountZ, sizeof(uint32_t));
+}
+
+#endif
 void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
                               const void* structExtension) {
     VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension);
@@ -33482,6 +40973,14 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
     }
     uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
     switch (structType) {
+#ifdef VK_VERSION_1_0
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
+            marshal_VkShaderModuleCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<const VkShaderModuleCreateInfo*>(structExtension));
+            break;
+        }
+#endif
 #ifdef VK_VERSION_1_1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
             marshal_VkPhysicalDeviceSubgroupProperties(
@@ -33972,6 +41471,194 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
+            marshal_VkPhysicalDeviceVulkan13Features(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: {
+            marshal_VkPhysicalDeviceVulkan13Properties(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceVulkan13Properties*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: {
+            marshal_VkPipelineCreationFeedbackCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
+            marshal_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
+            marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
+            marshal_VkPhysicalDevicePrivateDataFeatures(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: {
+            marshal_VkDevicePrivateDataCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<const VkDevicePrivateDataCreateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
+            marshal_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: {
+            marshal_VkMemoryBarrier2(vkStream, rootType,
+                                     reinterpret_cast<const VkMemoryBarrier2*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
+            marshal_VkPhysicalDeviceSynchronization2Features(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
+            marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
+            marshal_VkPhysicalDeviceImageRobustnessFeatures(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
+            marshal_VkPhysicalDeviceSubgroupSizeControlFeatures(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
+            marshal_VkPhysicalDeviceSubgroupSizeControlProperties(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: {
+            marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
+            marshal_VkPhysicalDeviceInlineUniformBlockFeatures(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
+            marshal_VkPhysicalDeviceInlineUniformBlockProperties(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: {
+            marshal_VkWriteDescriptorSetInlineUniformBlock(
+                vkStream, rootType,
+                reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: {
+            marshal_VkDescriptorPoolInlineUniformBlockCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
+            marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: {
+            marshal_VkPipelineRenderingCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<const VkPipelineRenderingCreateInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
+            marshal_VkPhysicalDeviceDynamicRenderingFeatures(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: {
+            marshal_VkCommandBufferInheritanceRenderingInfo(
+                vkStream, rootType,
+                reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
+            marshal_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
+            marshal_VkPhysicalDeviceShaderIntegerDotProductProperties(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
+            marshal_VkPhysicalDeviceTexelBufferAlignmentProperties(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
+            marshal_VkFormatProperties3(
+                vkStream, rootType, reinterpret_cast<const VkFormatProperties3*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
+            marshal_VkPhysicalDeviceMaintenance4Features(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
+            marshal_VkPhysicalDeviceMaintenance4Properties(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties*>(structExtension));
+            break;
+        }
+#endif
 #ifdef VK_KHR_swapchain
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
             marshal_VkImageSwapchainCreateInfoKHR(
@@ -34007,44 +41694,87 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
         }
 #endif
 #ifdef VK_KHR_video_queue
-        case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
-            marshal_VkVideoQueueFamilyProperties2KHR(
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: {
+            marshal_VkQueueFamilyQueryResultStatusPropertiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkQueueFamilyQueryResultStatusPropertiesKHR*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: {
+            marshal_VkQueueFamilyVideoPropertiesKHR(
                 vkStream, rootType,
-                reinterpret_cast<const VkVideoQueueFamilyProperties2KHR*>(structExtension));
+                reinterpret_cast<const VkQueueFamilyVideoPropertiesKHR*>(structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
-            marshal_VkVideoProfileKHR(vkStream, rootType,
-                                      reinterpret_cast<const VkVideoProfileKHR*>(structExtension));
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: {
+            marshal_VkVideoProfileInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoProfileInfoKHR*>(structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
-            marshal_VkVideoProfilesKHR(
-                vkStream, rootType, reinterpret_cast<const VkVideoProfilesKHR*>(structExtension));
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: {
+            marshal_VkVideoProfileListInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoProfileListInfoKHR*>(structExtension));
             break;
         }
 #endif
-#ifdef VK_KHR_dynamic_rendering
-        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
-            marshal_VkPipelineRenderingCreateInfoKHR(
+#ifdef VK_KHR_video_decode_queue
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: {
+            marshal_VkVideoDecodeCapabilitiesKHR(
                 vkStream, rootType,
-                reinterpret_cast<const VkPipelineRenderingCreateInfoKHR*>(structExtension));
+                reinterpret_cast<const VkVideoDecodeCapabilitiesKHR*>(structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
-            marshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: {
+            marshal_VkVideoDecodeUsageInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+                reinterpret_cast<const VkVideoDecodeUsageInfoKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_video_decode_h264
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: {
+            marshal_VkVideoDecodeH264ProfileInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoDecodeH264ProfileInfoKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: {
+            marshal_VkVideoDecodeH264CapabilitiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoDecodeH264CapabilitiesKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            marshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoKHR*>(
                     structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
-            marshal_VkCommandBufferInheritanceRenderingInfoKHR(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            marshal_VkVideoDecodeH264SessionParametersCreateInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR*>(
+                reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoKHR*>(
                     structExtension));
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: {
+            marshal_VkVideoDecodeH264PictureInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoDecodeH264PictureInfoKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: {
+            marshal_VkVideoDecodeH264DpbSlotInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_dynamic_rendering
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
             marshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
                 vkStream, rootType,
@@ -34177,6 +41907,7 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
         }
 #endif
 #ifdef VK_KHR_portability_subset
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
             marshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
                 vkStream, rootType,
@@ -34184,6 +41915,8 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
                     structExtension));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
             marshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
                 vkStream, rootType,
@@ -34191,6 +41924,7 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
                     structExtension));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_shader_clock
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
@@ -34200,14 +41934,66 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_KHR_shader_terminate_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
-            marshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+#ifdef VK_KHR_video_decode_h265
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: {
+            marshal_VkVideoDecodeH265ProfileInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoDecodeH265ProfileInfoKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: {
+            marshal_VkVideoDecodeH265CapabilitiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoDecodeH265CapabilitiesKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            marshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+                reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoKHR*>(
                     structExtension));
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            marshal_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoKHR*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: {
+            marshal_VkVideoDecodeH265PictureInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoDecodeH265PictureInfoKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: {
+            marshal_VkVideoDecodeH265DpbSlotInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_KHR_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: {
+            marshal_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoKHR*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: {
+            marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: {
+            marshal_VkQueueFamilyGlobalPriorityPropertiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesKHR*>(structExtension));
+            break;
+        }
 #endif
 #ifdef VK_KHR_fragment_shading_rate
         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
@@ -34263,19 +42049,11 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
-            marshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-                vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
-                    structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
-            marshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+#ifdef VK_KHR_pipeline_library
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+            marshal_VkPipelineLibraryCreateInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
-                    structExtension));
+                reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>(structExtension));
             break;
         }
 #endif
@@ -34293,30 +42071,69 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
         }
 #endif
 #ifdef VK_KHR_video_encode_queue
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: {
+            marshal_VkVideoEncodeCapabilitiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>(structExtension));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: {
+            marshal_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(
+                    structExtension));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: {
+            marshal_VkVideoEncodeUsageInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoEncodeUsageInfoKHR*>(structExtension));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: {
+            marshal_VkVideoEncodeRateControlLayerInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoEncodeRateControlLayerInfoKHR*>(structExtension));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
             marshal_VkVideoEncodeRateControlInfoKHR(
                 vkStream, rootType,
                 reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(structExtension));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_synchronization2
-        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
-            marshal_VkMemoryBarrier2KHR(
-                vkStream, rootType, reinterpret_cast<const VkMemoryBarrier2KHR*>(structExtension));
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
+            marshal_VkQueueFamilyCheckpointProperties2NV(
+                vkStream, rootType,
+                reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
-            marshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
+#endif
+#ifdef VK_KHR_fragment_shader_barycentric
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
+            marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
                 vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(
                     structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
-            marshal_VkQueueFamilyCheckpointProperties2NV(
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: {
+            marshal_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
                 vkStream, rootType,
-                reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension));
+                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(
+                    structExtension));
             break;
         }
 #endif
@@ -34330,15 +42147,6 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_KHR_zero_initialize_workgroup_memory
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
-            marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-                vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
-                    structExtension));
-            break;
-        }
-#endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
             marshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
@@ -34348,25 +42156,20 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_KHR_format_feature_flags2
-        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
-            marshal_VkFormatProperties3KHR(
+#ifdef VK_KHR_ray_tracing_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
+            marshal_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
                 vkStream, rootType,
-                reinterpret_cast<const VkFormatProperties3KHR*>(structExtension));
+                reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
+                    structExtension));
             break;
         }
 #endif
-#ifdef VK_KHR_maintenance4
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
-            marshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
-                vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
-            marshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
+#ifdef VK_KHR_ray_tracing_position_fetch
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
+            marshal_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
                 vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR*>(
+                reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(
                     structExtension));
             break;
         }
@@ -34441,18 +42244,15 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
         }
 #endif
 #ifdef VK_EXT_video_encode_h264
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
             marshal_VkVideoEncodeH264CapabilitiesEXT(
                 vkStream, rootType,
                 reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT*>(structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
-            marshal_VkVideoEncodeH264SessionCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension));
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
             marshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
                 vkStream, rootType,
@@ -34460,6 +42260,8 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
                     structExtension));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             marshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
                 vkStream, rootType,
@@ -34467,39 +42269,58 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
                     structExtension));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
             marshal_VkVideoEncodeH264VclFrameInfoEXT(
                 vkStream, rootType,
                 reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT*>(structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
-            marshal_VkVideoEncodeH264EmitPictureParametersEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: {
+            marshal_VkVideoEncodeH264DpbSlotInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT*>(
-                    structExtension));
+                reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoEXT*>(structExtension));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: {
+            marshal_VkVideoEncodeH264ProfileInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoEncodeH264ProfileInfoEXT*>(structExtension));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: {
+            marshal_VkVideoEncodeH264RateControlInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkVideoEncodeH264RateControlInfoEXT*>(structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
-            marshal_VkVideoEncodeH264ProfileEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: {
+            marshal_VkVideoEncodeH264RateControlLayerInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<const VkVideoEncodeH264ProfileEXT*>(structExtension));
+                reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoEXT*>(structExtension));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_EXT_video_encode_h265
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
             marshal_VkVideoEncodeH265CapabilitiesEXT(
                 vkStream, rootType,
                 reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT*>(structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
-            marshal_VkVideoEncodeH265SessionCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension));
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
             marshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
                 vkStream, rootType,
@@ -34507,6 +42328,8 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
                     structExtension));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             marshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
                 vkStream, rootType,
@@ -34514,77 +42337,47 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
                     structExtension));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
             marshal_VkVideoEncodeH265VclFrameInfoEXT(
                 vkStream, rootType,
                 reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT*>(structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
-            marshal_VkVideoEncodeH265EmitPictureParametersEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT*>(
-                    structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
-            marshal_VkVideoEncodeH265ProfileEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoEncodeH265ProfileEXT*>(structExtension));
-            break;
-        }
-#endif
-#ifdef VK_EXT_video_decode_h264
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
-            marshal_VkVideoDecodeH264ProfileEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH264ProfileEXT*>(structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
-            marshal_VkVideoDecodeH264CapabilitiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT*>(structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
-            marshal_VkVideoDecodeH264SessionCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            marshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT*>(
-                    structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            marshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: {
+            marshal_VkVideoEncodeH265DpbSlotInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
-                    structExtension));
+                reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoEXT*>(structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
-            marshal_VkVideoDecodeH264PictureInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: {
+            marshal_VkVideoEncodeH265ProfileInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT*>(structExtension));
+                reinterpret_cast<const VkVideoEncodeH265ProfileInfoEXT*>(structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
-            marshal_VkVideoDecodeH264MvcEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: {
+            marshal_VkVideoEncodeH265RateControlInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH264MvcEXT*>(structExtension));
+                reinterpret_cast<const VkVideoEncodeH265RateControlInfoEXT*>(structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
-            marshal_VkVideoDecodeH264DpbSlotInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: {
+            marshal_VkVideoEncodeH265RateControlLayerInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension));
+                reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoEXT*>(structExtension));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
@@ -34646,15 +42439,6 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_texture_compression_astc_hdr
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
-            marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
-                    structExtension));
-            break;
-        }
-#endif
 #ifdef VK_EXT_astc_decode_mode
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
             marshal_VkImageViewASTCDecodeModeEXT(
@@ -34669,6 +42453,28 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_robustness
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: {
+            marshal_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: {
+            marshal_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: {
+            marshal_VkPipelineRobustnessCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPipelineRobustnessCreateInfoEXT*>(structExtension));
+            break;
+        }
+#endif
 #ifdef VK_EXT_conditional_rendering
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
             marshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
@@ -34777,6 +42583,12 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
         }
 #endif
 #ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+            marshal_VkDebugUtilsObjectNameInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(structExtension));
+            break;
+        }
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
             marshal_VkDebugUtilsMessengerCreateInfoEXT(
                 vkStream, rootType,
@@ -34818,36 +42630,6 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_inline_uniform_block
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
-            marshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
-                    structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
-            marshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
-                    structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
-            marshal_VkWriteDescriptorSetInlineUniformBlockEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(
-                    structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
-            marshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
-                    structExtension));
-            break;
-        }
-#endif
 #ifdef VK_EXT_sample_locations
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
             marshal_VkSampleLocationsInfoEXT(
@@ -35054,14 +42836,6 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
-            marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension));
-            break;
-        }
-#endif
 #ifdef VK_EXT_external_memory_host
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
             marshal_VkImportMemoryHostPointerInfoEXT(
@@ -35093,52 +42867,6 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_video_decode_h265
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
-            marshal_VkVideoDecodeH265ProfileEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH265ProfileEXT*>(structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
-            marshal_VkVideoDecodeH265CapabilitiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT*>(structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
-            marshal_VkVideoDecodeH265SessionCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            marshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT*>(
-                    structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            marshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
-                    structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
-            marshal_VkVideoDecodeH265PictureInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT*>(structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
-            marshal_VkVideoDecodeH265DpbSlotInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension));
-            break;
-        }
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
             marshal_VkDeviceMemoryOverallocationCreateInfoAMD(
@@ -35179,14 +42907,6 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_pipeline_creation_feedback
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
-            marshal_VkPipelineCreationFeedbackCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension));
-            break;
-        }
-#endif
 #ifdef VK_NV_compute_shader_derivatives
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
             marshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
@@ -35210,15 +42930,6 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_NV_fragment_shader_barycentric
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
-            marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-                vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
-                    structExtension));
-            break;
-        }
-#endif
 #ifdef VK_NV_shader_image_footprint
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
             marshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -35383,29 +43094,6 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_subgroup_size_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
-            marshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
-                    structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
-            marshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
-                    structExtension));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
-            marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
-                    structExtension));
-            break;
-        }
-#endif
 #ifdef VK_AMD_shader_core_properties2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
             marshal_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -35641,14 +43329,58 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
-            marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: {
+            marshal_VkSurfacePresentModeEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkSurfacePresentModeEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
+            marshal_VkSurfacePresentScalingCapabilitiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkSurfacePresentScalingCapabilitiesEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
+            marshal_VkSurfacePresentModeCompatibilityEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkSurfacePresentModeCompatibilityEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
                 vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+                reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(
                     structExtension));
             break;
         }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: {
+            marshal_VkSwapchainPresentFenceInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkSwapchainPresentFenceInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: {
+            marshal_VkSwapchainPresentModesCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkSwapchainPresentModesCreateInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: {
+            marshal_VkSwapchainPresentModeInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkSwapchainPresentModeInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: {
+            marshal_VkSwapchainPresentScalingCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkSwapchainPresentScalingCreateInfoEXT*>(structExtension));
+            break;
+        }
 #endif
 #ifdef VK_NV_device_generated_commands
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
@@ -35697,13 +43429,6 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
                     structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
-            marshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
-                    structExtension));
-            break;
-        }
 #endif
 #ifdef VK_QCOM_render_pass_transform
         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
@@ -35771,26 +43496,23 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_private_data
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
-            marshal_VkPhysicalDevicePrivateDataFeaturesEXT(
+#ifdef VK_NV_present_barrier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
+            marshal_VkPhysicalDevicePresentBarrierFeaturesNV(
                 vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension));
+                reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
-            marshal_VkDevicePrivateDataCreateInfoEXT(
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: {
+            marshal_VkSurfaceCapabilitiesPresentBarrierNV(
                 vkStream, rootType,
-                reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension));
+                reinterpret_cast<const VkSurfaceCapabilitiesPresentBarrierNV*>(structExtension));
             break;
         }
-#endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
-            marshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: {
+            marshal_VkSwapchainPresentBarrierCreateInfoNV(
                 vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
-                    structExtension));
+                reinterpret_cast<const VkSwapchainPresentBarrierCreateInfoNV*>(structExtension));
             break;
         }
 #endif
@@ -35809,6 +43531,150 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_NV_low_latency
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: {
+            marshal_VkQueryLowLatencySupportNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkQueryLowLatencySupportNV*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_metal_objects
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: {
+            marshal_VkExportMetalObjectCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkExportMetalObjectCreateInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: {
+            marshal_VkExportMetalDeviceInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkExportMetalDeviceInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: {
+            marshal_VkExportMetalCommandQueueInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkExportMetalCommandQueueInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: {
+            marshal_VkExportMetalBufferInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkExportMetalBufferInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: {
+            marshal_VkImportMetalBufferInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkImportMetalBufferInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: {
+            marshal_VkExportMetalTextureInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkExportMetalTextureInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: {
+            marshal_VkImportMetalTextureInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkImportMetalTextureInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: {
+            marshal_VkExportMetalIOSurfaceInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkExportMetalIOSurfaceInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: {
+            marshal_VkImportMetalIOSurfaceInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkImportMetalIOSurfaceInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            marshal_VkExportMetalSharedEventInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkExportMetalSharedEventInfoEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            marshal_VkImportMetalSharedEventInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkImportMetalSharedEventInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: {
+            marshal_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: {
+            marshal_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: {
+            marshal_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: {
+            marshal_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: {
+            marshal_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: {
+            marshal_VkGraphicsPipelineLibraryCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkGraphicsPipelineLibraryCreateInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
+            marshal_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(
+                    structExtension));
+            break;
+        }
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
             marshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -35887,11 +43753,32 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_image_robustness
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
-            marshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+#ifdef VK_EXT_image_compression_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
+            marshal_VkImageCompressionControlEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkImageCompressionControlEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
+            marshal_VkImageCompressionPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkImageCompressionPropertiesEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
                 vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(
+                reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(
                     structExtension));
             break;
         }
@@ -35904,6 +43791,24 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_device_fault
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceFaultFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<
+                    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
 #ifdef VK_EXT_rgba10x6_formats
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
             marshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
@@ -35914,17 +43819,17 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
         }
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
-            marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
                 vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+                reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(
                     structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
-            marshal_VkMutableDescriptorTypeCreateInfoVALVE(
+        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: {
+            marshal_VkMutableDescriptorTypeCreateInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension));
+                reinterpret_cast<const VkMutableDescriptorTypeCreateInfoEXT*>(structExtension));
             break;
         }
 #endif
@@ -35945,6 +43850,37 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_device_address_binding_report
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: {
+            marshal_VkDeviceAddressBindingCallbackDataEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkDeviceAddressBindingCallbackDataEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clip_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: {
+            marshal_VkPipelineViewportDepthClipControlCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
             marshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
@@ -36023,6 +43959,38 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
+            marshal_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<
+                    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: {
+            marshal_VkSubpassResolvePerformanceQueryEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkSubpassResolvePerformanceQueryEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: {
+            marshal_VkMultisampledRenderToSingleSampledInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkMultisampledRenderToSingleSampledInfoEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
             marshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
@@ -36047,6 +44015,15 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_primitives_generated_query
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
+            marshal_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
 #ifdef VK_GOOGLE_gfxstream
         case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
             marshal_VkImportColorBufferGOOGLE(
@@ -36065,18 +44042,18 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority_query
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
-            marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+#ifdef VK_EXT_image_view_min_lod
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
                 vkStream, rootType,
-                reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
+                reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(
                     structExtension));
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
-            marshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: {
+            marshal_VkImageViewMinLodCreateInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension));
+                reinterpret_cast<const VkImageViewMinLodCreateInfoEXT*>(structExtension));
             break;
         }
 #endif
@@ -36094,6 +44071,99 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_tile_image
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: {
+            marshal_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderTileImagePropertiesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: {
+            marshal_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: {
+            marshal_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_displacement_micromap
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
+            marshal_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(
+                    structExtension));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: {
+            marshal_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(
+                    structExtension));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: {
+            marshal_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkAccelerationStructureTrianglesDisplacementMicromapNV*>(
+                    structExtension));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
+            marshal_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: {
+            marshal_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(
+                    structExtension));
+            break;
+        }
+#endif
 #ifdef VK_EXT_border_color_swizzle
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
             marshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
@@ -36119,6 +44189,387 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_ARM_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: {
+            marshal_VkPhysicalDeviceShaderCorePropertiesARM(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: {
+            marshal_VkImageViewSlicedCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkImageViewSlicedCreateInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
+            marshal_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: {
+            marshal_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: {
+            marshal_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: {
+            marshal_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+                vkStream, rootType,
+                reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_copy_memory_indirect
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
+            marshal_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: {
+            marshal_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_memory_decompression
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: {
+            marshal_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: {
+            marshal_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_linear_color_attachment
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
+            marshal_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<
+                    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_image_processing
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: {
+            marshal_VkImageViewSampleWeightCreateInfoQCOM(
+                vkStream, rootType,
+                reinterpret_cast<const VkImageViewSampleWeightCreateInfoQCOM*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
+            marshal_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: {
+            marshal_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceImageProcessingPropertiesQCOM*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: {
+            marshal_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: {
+            marshal_VkRenderPassCreationControlEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkRenderPassCreationControlEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+            marshal_VkRenderPassCreationFeedbackCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkRenderPassCreationFeedbackCreateInfoEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: {
+            marshal_VkRenderPassSubpassFeedbackCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkRenderPassSubpassFeedbackCreateInfoEXT*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: {
+            marshal_VkDirectDriverLoadingListLUNARG(
+                vkStream, rootType,
+                reinterpret_cast<const VkDirectDriverLoadingListLUNARG*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_module_identifier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: {
+            marshal_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: {
+            marshal_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_optical_flow
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
+            marshal_VkPhysicalDeviceOpticalFlowFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: {
+            marshal_VkPhysicalDeviceOpticalFlowPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceOpticalFlowPropertiesNV*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: {
+            marshal_VkOpticalFlowImageFormatInfoNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkOpticalFlowImageFormatInfoNV*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: {
+            marshal_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkOpticalFlowSessionCreatePrivateDataInfoNV*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_legacy_dithering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: {
+            marshal_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_object
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceShaderObjectFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: {
+            marshal_VkPhysicalDeviceShaderObjectPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderObjectPropertiesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_tile_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
+            marshal_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_SEC_amigo_profiling
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
+            marshal_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: {
+            marshal_VkAmigoProfilingSubmitInfoSEC(
+                vkStream, rootType,
+                reinterpret_cast<const VkAmigoProfilingSubmitInfoSEC*>(structExtension));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
+            marshal_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: {
+            marshal_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
+            marshal_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_ARM_shader_core_builtins
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
+            marshal_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: {
+            marshal_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
+            marshal_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
+            marshal_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(
+                    structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: {
+            marshal_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+                vkStream, rootType,
+                reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(
+                    structExtension));
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<
+                    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(
+                    structExtension));
+            break;
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
             marshal_VkWriteDescriptorSetAccelerationStructureKHR(
@@ -36166,6 +44617,20 @@ void marshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
             break;
         }
 #endif
+#ifdef VK_EXT_mesh_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
+            marshal_VkPhysicalDeviceMeshShaderFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(structExtension));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: {
+            marshal_VkPhysicalDeviceMeshShaderPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesEXT*>(structExtension));
+            break;
+        }
+#endif
         default: {
             // fatal; the switch is only taken if the extension struct is known
             abort();
@@ -36194,6 +44659,14 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
     }
     uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
     switch (structType) {
+#ifdef VK_VERSION_1_0
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
+            unmarshal_VkShaderModuleCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkShaderModuleCreateInfo*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_VERSION_1_1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
             unmarshal_VkPhysicalDeviceSubgroupProperties(
@@ -36676,6 +45149,193 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
+            unmarshal_VkPhysicalDeviceVulkan13Features(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceVulkan13Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: {
+            unmarshal_VkPhysicalDeviceVulkan13Properties(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceVulkan13Properties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: {
+            unmarshal_VkPipelineCreationFeedbackCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineCreationFeedbackCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
+            unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
+            unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
+            unmarshal_VkPhysicalDevicePrivateDataFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePrivateDataFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: {
+            unmarshal_VkDevicePrivateDataCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkDevicePrivateDataCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
+            unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: {
+            unmarshal_VkMemoryBarrier2(vkStream, rootType,
+                                       reinterpret_cast<VkMemoryBarrier2*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
+            unmarshal_VkPhysicalDeviceSynchronization2Features(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceSynchronization2Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
+            unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
+            unmarshal_VkPhysicalDeviceImageRobustnessFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceImageRobustnessFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
+            unmarshal_VkPhysicalDeviceSubgroupSizeControlFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
+            unmarshal_VkPhysicalDeviceSubgroupSizeControlProperties(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlProperties*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: {
+            unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
+            unmarshal_VkPhysicalDeviceInlineUniformBlockFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
+            unmarshal_VkPhysicalDeviceInlineUniformBlockProperties(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockProperties*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: {
+            unmarshal_VkWriteDescriptorSetInlineUniformBlock(
+                vkStream, rootType,
+                reinterpret_cast<VkWriteDescriptorSetInlineUniformBlock*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: {
+            unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
+            unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: {
+            unmarshal_VkPipelineRenderingCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineRenderingCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
+            unmarshal_VkPhysicalDeviceDynamicRenderingFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: {
+            unmarshal_VkCommandBufferInheritanceRenderingInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkCommandBufferInheritanceRenderingInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
+            unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
+            unmarshal_VkPhysicalDeviceShaderIntegerDotProductProperties(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductProperties*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
+            unmarshal_VkPhysicalDeviceTexelBufferAlignmentProperties(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentProperties*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
+            unmarshal_VkFormatProperties3(
+                vkStream, rootType, reinterpret_cast<VkFormatProperties3*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
+            unmarshal_VkPhysicalDeviceMaintenance4Features(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMaintenance4Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
+            unmarshal_VkPhysicalDeviceMaintenance4Properties(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMaintenance4Properties*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_KHR_swapchain
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
             unmarshal_VkImageSwapchainCreateInfoKHR(
@@ -36711,43 +45371,86 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
         }
 #endif
 #ifdef VK_KHR_video_queue
-        case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
-            unmarshal_VkVideoQueueFamilyProperties2KHR(
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: {
+            unmarshal_VkQueueFamilyQueryResultStatusPropertiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkQueueFamilyQueryResultStatusPropertiesKHR*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: {
+            unmarshal_VkQueueFamilyVideoPropertiesKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
+                reinterpret_cast<VkQueueFamilyVideoPropertiesKHR*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
-            unmarshal_VkVideoProfileKHR(vkStream, rootType,
-                                        reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: {
+            unmarshal_VkVideoProfileInfoKHR(
+                vkStream, rootType, reinterpret_cast<VkVideoProfileInfoKHR*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
-            unmarshal_VkVideoProfilesKHR(
-                vkStream, rootType, reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: {
+            unmarshal_VkVideoProfileListInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoProfileListInfoKHR*>(structExtension_out));
             break;
         }
 #endif
-#ifdef VK_KHR_dynamic_rendering
-        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
-            unmarshal_VkPipelineRenderingCreateInfoKHR(
+#ifdef VK_KHR_video_decode_queue
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: {
+            unmarshal_VkVideoDecodeCapabilitiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeCapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: {
+            unmarshal_VkVideoDecodeUsageInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeUsageInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_video_decode_h264
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: {
+            unmarshal_VkVideoDecodeH264ProfileInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH264ProfileInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: {
+            unmarshal_VkVideoDecodeH264CapabilitiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH264CapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            unmarshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
+                reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoKHR*>(
+                    structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
-            unmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            unmarshal_VkVideoDecodeH264SessionParametersCreateInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+                reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoKHR*>(
                     structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
-            unmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: {
+            unmarshal_VkVideoDecodeH264PictureInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
+                reinterpret_cast<VkVideoDecodeH264PictureInfoKHR*>(structExtension_out));
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: {
+            unmarshal_VkVideoDecodeH264DpbSlotInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH264DpbSlotInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_dynamic_rendering
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
             unmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
                 vkStream, rootType,
@@ -36880,6 +45583,7 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
         }
 #endif
 #ifdef VK_KHR_portability_subset
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
             unmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
                 vkStream, rootType,
@@ -36887,6 +45591,8 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
                     structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
             unmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
                 vkStream, rootType,
@@ -36894,6 +45600,7 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
                     structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_shader_clock
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
@@ -36903,14 +45610,66 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_KHR_shader_terminate_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
-            unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+#ifdef VK_KHR_video_decode_h265
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: {
+            unmarshal_VkVideoDecodeH265ProfileInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH265ProfileInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: {
+            unmarshal_VkVideoDecodeH265CapabilitiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH265CapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            unmarshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+                reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoKHR*>(
                     structExtension_out));
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            unmarshal_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoKHR*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: {
+            unmarshal_VkVideoDecodeH265PictureInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH265PictureInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: {
+            unmarshal_VkVideoDecodeH265DpbSlotInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH265DpbSlotInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: {
+            unmarshal_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: {
+            unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: {
+            unmarshal_VkQueueFamilyGlobalPriorityPropertiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesKHR*>(structExtension_out));
+            break;
+        }
 #endif
 #ifdef VK_KHR_fragment_shading_rate
         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
@@ -36966,19 +45725,11 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
-            unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
-            unmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+#ifdef VK_KHR_pipeline_library
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+            unmarshal_VkPipelineLibraryCreateInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
-                    structExtension_out));
+                reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(structExtension_out));
             break;
         }
 #endif
@@ -36996,30 +45747,69 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
         }
 #endif
 #ifdef VK_KHR_video_encode_queue
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: {
+            unmarshal_VkVideoEncodeCapabilitiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoEncodeCapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: {
+            unmarshal_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(
+                    structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: {
+            unmarshal_VkVideoEncodeUsageInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoEncodeUsageInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: {
+            unmarshal_VkVideoEncodeRateControlLayerInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
             unmarshal_VkVideoEncodeRateControlInfoKHR(
                 vkStream, rootType,
                 reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_synchronization2
-        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
-            unmarshal_VkMemoryBarrier2KHR(
-                vkStream, rootType, reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
+            unmarshal_VkQueueFamilyCheckpointProperties2NV(
+                vkStream, rootType,
+                reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
-            unmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
+#endif
+#ifdef VK_KHR_fragment_shader_barycentric
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
+            unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(
                     structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
-            unmarshal_VkQueueFamilyCheckpointProperties2NV(
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: {
+            unmarshal_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkQueueFamilyCheckpointProperties2NV*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(
+                    structExtension_out));
             break;
         }
 #endif
@@ -37032,15 +45822,6 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_KHR_zero_initialize_workgroup_memory
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
-            unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
             unmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
@@ -37050,24 +45831,21 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_KHR_format_feature_flags2
-        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
-            unmarshal_VkFormatProperties3KHR(
-                vkStream, rootType, reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
-            break;
-        }
-#endif
-#ifdef VK_KHR_maintenance4
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
-            unmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
+#ifdef VK_KHR_ray_tracing_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
+            unmarshal_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
+                    structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
-            unmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
+            unmarshal_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(
+                    structExtension_out));
             break;
         }
 #endif
@@ -37139,18 +45917,15 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
         }
 #endif
 #ifdef VK_EXT_video_encode_h264
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
             unmarshal_VkVideoEncodeH264CapabilitiesEXT(
                 vkStream, rootType,
                 reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
-            unmarshal_VkVideoEncodeH264SessionCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
             unmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
                 vkStream, rootType,
@@ -37158,6 +45933,8 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
                     structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             unmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
                 vkStream, rootType,
@@ -37165,38 +45942,58 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
                     structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
             unmarshal_VkVideoEncodeH264VclFrameInfoEXT(
                 vkStream, rootType,
                 reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
-            unmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: {
+            unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoEncodeH264DpbSlotInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: {
+            unmarshal_VkVideoEncodeH264ProfileInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH264ProfileInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
-            unmarshal_VkVideoEncodeH264ProfileEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: {
+            unmarshal_VkVideoEncodeH264RateControlInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH264RateControlInfoEXT*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: {
+            unmarshal_VkVideoEncodeH264RateControlLayerInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_EXT_video_encode_h265
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
             unmarshal_VkVideoEncodeH265CapabilitiesEXT(
                 vkStream, rootType,
                 reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
-            unmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
             unmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
                 vkStream, rootType,
@@ -37204,6 +46001,8 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
                     structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             unmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
                 vkStream, rootType,
@@ -37211,76 +46010,47 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
                     structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
             unmarshal_VkVideoEncodeH265VclFrameInfoEXT(
                 vkStream, rootType,
                 reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
-            unmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
-            unmarshal_VkVideoEncodeH265ProfileEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
-            break;
-        }
-#endif
-#ifdef VK_EXT_video_decode_h264
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
-            unmarshal_VkVideoDecodeH264ProfileEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
-            unmarshal_VkVideoDecodeH264CapabilitiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
-            unmarshal_VkVideoDecodeH264SessionCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            unmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            unmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: {
+            unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
-                    structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265DpbSlotInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
-            unmarshal_VkVideoDecodeH264PictureInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: {
+            unmarshal_VkVideoEncodeH265ProfileInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265ProfileInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
-            unmarshal_VkVideoDecodeH264MvcEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: {
+            unmarshal_VkVideoEncodeH265RateControlInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265RateControlInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
-            unmarshal_VkVideoDecodeH264DpbSlotInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: {
+            unmarshal_VkVideoEncodeH265RateControlLayerInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoEXT*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
@@ -37342,15 +46112,6 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_EXT_texture_compression_astc_hdr
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
-            unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_astc_decode_mode
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
             unmarshal_VkImageViewASTCDecodeModeEXT(
@@ -37365,6 +46126,28 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_robustness
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: {
+            unmarshal_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: {
+            unmarshal_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: {
+            unmarshal_VkPipelineRobustnessCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineRobustnessCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_conditional_rendering
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
             unmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
@@ -37471,6 +46254,12 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
         }
 #endif
 #ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+            unmarshal_VkDebugUtilsObjectNameInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(structExtension_out));
+            break;
+        }
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
             unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
                 vkStream, rootType,
@@ -37512,35 +46301,6 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_EXT_inline_uniform_block
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
-            unmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
-            unmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
-            unmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
-            unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_sample_locations
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
             unmarshal_VkSampleLocationsInfoEXT(
@@ -37742,14 +46502,6 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
-            unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_external_memory_host
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
             unmarshal_VkImportMemoryHostPointerInfoEXT(
@@ -37781,52 +46533,6 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_EXT_video_decode_h265
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
-            unmarshal_VkVideoDecodeH265ProfileEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
-            unmarshal_VkVideoDecodeH265CapabilitiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
-            unmarshal_VkVideoDecodeH265SessionCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            unmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            unmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
-            unmarshal_VkVideoDecodeH265PictureInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
-            unmarshal_VkVideoDecodeH265DpbSlotInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
             unmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
@@ -37865,14 +46571,6 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_EXT_pipeline_creation_feedback
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
-            unmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_NV_compute_shader_derivatives
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
             unmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
@@ -37896,15 +46594,6 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_NV_fragment_shader_barycentric
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
-            unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_NV_shader_image_footprint
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
             unmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -38067,29 +46756,6 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_EXT_subgroup_size_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
-            unmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
-            unmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
-            unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_AMD_shader_core_properties2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
             unmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -38320,14 +46986,58 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
-            unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: {
+            unmarshal_VkSurfacePresentModeEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSurfacePresentModeEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
+            unmarshal_VkSurfacePresentScalingCapabilitiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
+            unmarshal_VkSurfacePresentModeCompatibilityEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSurfacePresentModeCompatibilityEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+                reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(
                     structExtension_out));
             break;
         }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: {
+            unmarshal_VkSwapchainPresentFenceInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSwapchainPresentFenceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: {
+            unmarshal_VkSwapchainPresentModesCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSwapchainPresentModesCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: {
+            unmarshal_VkSwapchainPresentModeInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSwapchainPresentModeInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: {
+            unmarshal_VkSwapchainPresentScalingCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSwapchainPresentScalingCreateInfoEXT*>(structExtension_out));
+            break;
+        }
 #endif
 #ifdef VK_NV_device_generated_commands
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
@@ -38375,13 +47085,6 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
                     structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
-            unmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
-                    structExtension_out));
-            break;
-        }
 #endif
 #ifdef VK_QCOM_render_pass_transform
         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
@@ -38449,26 +47152,23 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_EXT_private_data
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
-            unmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
+#ifdef VK_NV_present_barrier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
+            unmarshal_VkPhysicalDevicePresentBarrierFeaturesNV(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDevicePresentBarrierFeaturesNV*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
-            unmarshal_VkDevicePrivateDataCreateInfoEXT(
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: {
+            unmarshal_VkSurfaceCapabilitiesPresentBarrierNV(
                 vkStream, rootType,
-                reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
+                reinterpret_cast<VkSurfaceCapabilitiesPresentBarrierNV*>(structExtension_out));
             break;
         }
-#endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
-            unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: {
+            unmarshal_VkSwapchainPresentBarrierCreateInfoNV(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
-                    structExtension_out));
+                reinterpret_cast<VkSwapchainPresentBarrierCreateInfoNV*>(structExtension_out));
             break;
         }
 #endif
@@ -38487,6 +47187,149 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
+#ifdef VK_NV_low_latency
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: {
+            unmarshal_VkQueryLowLatencySupportNV(
+                vkStream, rootType,
+                reinterpret_cast<VkQueryLowLatencySupportNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_metal_objects
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: {
+            unmarshal_VkExportMetalObjectCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalObjectCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: {
+            unmarshal_VkExportMetalDeviceInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalDeviceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: {
+            unmarshal_VkExportMetalCommandQueueInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalCommandQueueInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: {
+            unmarshal_VkExportMetalBufferInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalBufferInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: {
+            unmarshal_VkImportMetalBufferInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImportMetalBufferInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: {
+            unmarshal_VkExportMetalTextureInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalTextureInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: {
+            unmarshal_VkImportMetalTextureInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImportMetalTextureInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: {
+            unmarshal_VkExportMetalIOSurfaceInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalIOSurfaceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: {
+            unmarshal_VkImportMetalIOSurfaceInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImportMetalIOSurfaceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            unmarshal_VkExportMetalSharedEventInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalSharedEventInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            unmarshal_VkImportMetalSharedEventInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImportMetalSharedEventInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: {
+            unmarshal_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: {
+            unmarshal_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: {
+            unmarshal_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: {
+            unmarshal_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: {
+            unmarshal_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: {
+            unmarshal_VkGraphicsPipelineLibraryCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkGraphicsPipelineLibraryCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
+            unmarshal_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
             unmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -38565,11 +47408,33 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_EXT_image_robustness
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
-            unmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+#ifdef VK_EXT_image_compression_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
+            unmarshal_VkImageCompressionControlEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImageCompressionControlEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
+            unmarshal_VkImageCompressionPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImageCompressionPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(
+                    structExtension_out));
             break;
         }
 #endif
@@ -38581,6 +47446,23 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
+#ifdef VK_EXT_device_fault
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceFaultFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceFaultFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_rgba10x6_formats
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
             unmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
@@ -38590,17 +47472,17 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
         }
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
-            unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+                reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(
                     structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
-            unmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
+        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: {
+            unmarshal_VkMutableDescriptorTypeCreateInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
+                reinterpret_cast<VkMutableDescriptorTypeCreateInfoEXT*>(structExtension_out));
             break;
         }
 #endif
@@ -38621,6 +47503,37 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
+#ifdef VK_EXT_device_address_binding_report
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: {
+            unmarshal_VkDeviceAddressBindingCallbackDataEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clip_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: {
+            unmarshal_VkPipelineViewportDepthClipControlCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
             unmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
@@ -38698,6 +47611,36 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
+            unmarshal_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: {
+            unmarshal_VkSubpassResolvePerformanceQueryEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSubpassResolvePerformanceQueryEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: {
+            unmarshal_VkMultisampledRenderToSingleSampledInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkMultisampledRenderToSingleSampledInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
             unmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
@@ -38722,6 +47665,15 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
+#ifdef VK_EXT_primitives_generated_query
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
+            unmarshal_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_GOOGLE_gfxstream
         case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
             unmarshal_VkImportColorBufferGOOGLE(
@@ -38740,18 +47692,17 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority_query
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
-            unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+#ifdef VK_EXT_image_view_min_lod
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
-                    structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
-            unmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: {
+            unmarshal_VkImageViewMinLodCreateInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
+                reinterpret_cast<VkImageViewMinLodCreateInfoEXT*>(structExtension_out));
             break;
         }
 #endif
@@ -38769,6 +47720,96 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_tile_image
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: {
+            unmarshal_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderTileImagePropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: {
+            unmarshal_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: {
+            unmarshal_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_displacement_micromap
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
+            unmarshal_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: {
+            unmarshal_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: {
+            unmarshal_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+                vkStream, rootType,
+                reinterpret_cast<VkAccelerationStructureTrianglesDisplacementMicromapNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
+            unmarshal_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: {
+            unmarshal_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_border_color_swizzle
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
             unmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
@@ -38794,6 +47835,380 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
+#ifdef VK_ARM_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: {
+            unmarshal_VkPhysicalDeviceShaderCorePropertiesARM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesARM*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: {
+            unmarshal_VkImageViewSlicedCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImageViewSlicedCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
+            unmarshal_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: {
+            unmarshal_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: {
+            unmarshal_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: {
+            unmarshal_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_copy_memory_indirect
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
+            unmarshal_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: {
+            unmarshal_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_memory_decompression
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: {
+            unmarshal_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: {
+            unmarshal_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_linear_color_attachment
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
+            unmarshal_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_image_processing
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: {
+            unmarshal_VkImageViewSampleWeightCreateInfoQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkImageViewSampleWeightCreateInfoQCOM*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
+            unmarshal_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: {
+            unmarshal_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceImageProcessingPropertiesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: {
+            unmarshal_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: {
+            unmarshal_VkRenderPassCreationControlEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkRenderPassCreationControlEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+            unmarshal_VkRenderPassCreationFeedbackCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkRenderPassCreationFeedbackCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: {
+            unmarshal_VkRenderPassSubpassFeedbackCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkRenderPassSubpassFeedbackCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: {
+            unmarshal_VkDirectDriverLoadingListLUNARG(
+                vkStream, rootType,
+                reinterpret_cast<VkDirectDriverLoadingListLUNARG*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_module_identifier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: {
+            unmarshal_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: {
+            unmarshal_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_optical_flow
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
+            unmarshal_VkPhysicalDeviceOpticalFlowFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceOpticalFlowFeaturesNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: {
+            unmarshal_VkPhysicalDeviceOpticalFlowPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceOpticalFlowPropertiesNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: {
+            unmarshal_VkOpticalFlowImageFormatInfoNV(
+                vkStream, rootType,
+                reinterpret_cast<VkOpticalFlowImageFormatInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: {
+            unmarshal_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+                vkStream, rootType,
+                reinterpret_cast<VkOpticalFlowSessionCreatePrivateDataInfoNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_legacy_dithering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: {
+            unmarshal_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_object
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceShaderObjectFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderObjectFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: {
+            unmarshal_VkPhysicalDeviceShaderObjectPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderObjectPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_tile_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
+            unmarshal_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_SEC_amigo_profiling
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
+            unmarshal_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: {
+            unmarshal_VkAmigoProfilingSubmitInfoSEC(
+                vkStream, rootType,
+                reinterpret_cast<VkAmigoProfilingSubmitInfoSEC*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
+            unmarshal_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: {
+            unmarshal_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
+            unmarshal_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ARM_shader_core_builtins
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
+            unmarshal_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: {
+            unmarshal_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
+            unmarshal_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
+            unmarshal_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: {
+            unmarshal_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
             unmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
@@ -38841,6 +48256,20 @@ void unmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType
             break;
         }
 #endif
+#ifdef VK_EXT_mesh_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
+            unmarshal_VkPhysicalDeviceMeshShaderFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: {
+            unmarshal_VkPhysicalDeviceMeshShaderPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
         default: {
             // fatal; the switch is only taken if the extension struct is known
             abort();
@@ -39936,28 +49365,6 @@ const char* api_opcode_to_string(const uint32_t opcode) {
         case OP_vkGetLinearImageLayoutGOOGLE: {
             return "OP_vkGetLinearImageLayoutGOOGLE";
         }
-#endif
-#ifdef VK_MVK_moltenvk
-        case OP_vkGetMTLDeviceMVK: {
-            return "OP_vkGetMTLDeviceMVK";
-        }
-        case OP_vkSetMTLTextureMVK: {
-            return "OP_vkSetMTLTextureMVK";
-        }
-        case OP_vkGetMTLTextureMVK: {
-            return "OP_vkGetMTLTextureMVK";
-        }
-        case OP_vkGetMTLBufferMVK: {
-            return "OP_vkGetMTLBufferMVK";
-        }
-        case OP_vkUseIOSurfaceMVK: {
-            return "OP_vkUseIOSurfaceMVK";
-        }
-        case OP_vkGetIOSurfaceMVK: {
-            return "OP_vkGetIOSurfaceMVK";
-        }
-#endif
-#ifdef VK_GOOGLE_gfxstream
         case OP_vkQueueFlushCommandsGOOGLE: {
             return "OP_vkQueueFlushCommandsGOOGLE";
         }
@@ -39965,6 +49372,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkGetBlobGOOGLE";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetRasterizationSamplesEXT: {
+            return "OP_vkCmdSetRasterizationSamplesEXT";
+        }
+#endif
 #ifdef VK_KHR_dynamic_rendering
         case OP_vkCmdEndRenderingKHR: {
             return "OP_vkCmdEndRenderingKHR";
@@ -39990,6 +49402,16 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdSetColorWriteEnableEXT";
         }
 #endif
+#ifdef VK_EXT_descriptor_buffer
+        case OP_vkGetDescriptorEXT: {
+            return "OP_vkGetDescriptorEXT";
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetColorBlendAdvancedEXT: {
+            return "OP_vkCmdSetColorBlendAdvancedEXT";
+        }
+#endif
 #ifdef VK_NV_ray_tracing
         case OP_vkBindAccelerationStructureMemoryNV: {
             return "OP_vkBindAccelerationStructureMemoryNV";
@@ -40005,6 +49427,16 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkGetDeferredOperationMaxConcurrencyKHR";
         }
 #endif
+#ifdef VK_NV_optical_flow
+        case OP_vkCreateOpticalFlowSessionNV: {
+            return "OP_vkCreateOpticalFlowSessionNV";
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case OP_vkCmdBindDescriptorBufferEmbeddedSamplersEXT: {
+            return "OP_vkCmdBindDescriptorBufferEmbeddedSamplersEXT";
+        }
+#endif
 #ifdef VK_EXT_calibrated_timestamps
         case OP_vkGetCalibratedTimestampsEXT: {
             return "OP_vkGetCalibratedTimestampsEXT";
@@ -40035,11 +49467,24 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdSetScissorWithCountEXT";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetViewportWScalingEnableNV: {
+            return "OP_vkCmdSetViewportWScalingEnableNV";
+        }
+        case OP_vkCmdSetRasterizationStreamEXT: {
+            return "OP_vkCmdSetRasterizationStreamEXT";
+        }
+#endif
 #ifdef VK_KHR_ray_tracing_pipeline
         case OP_vkGetRayTracingShaderGroupStackSizeKHR: {
             return "OP_vkGetRayTracingShaderGroupStackSizeKHR";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetSampleMaskEXT: {
+            return "OP_vkCmdSetSampleMaskEXT";
+        }
+#endif
 #ifdef VK_EXT_full_screen_exclusive
         case OP_vkGetDeviceGroupSurfacePresentModes2EXT: {
             return "OP_vkGetDeviceGroupSurfacePresentModes2EXT";
@@ -40060,6 +49505,14 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdWriteAccelerationStructuresPropertiesNV";
         }
 #endif
+#ifdef VK_EXT_opacity_micromap
+        case OP_vkCmdBuildMicromapsEXT: {
+            return "OP_vkCmdBuildMicromapsEXT";
+        }
+        case OP_vkWriteMicromapsPropertiesEXT: {
+            return "OP_vkWriteMicromapsPropertiesEXT";
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
         case OP_vkCmdSetPatchControlPointsEXT: {
             return "OP_vkCmdSetPatchControlPointsEXT";
@@ -40070,11 +49523,26 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkDestroyPrivateDataSlotEXT";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdSetDepthTestEnable: {
+            return "OP_vkCmdSetDepthTestEnable";
+        }
+#endif
 #ifdef VK_NV_ray_tracing
         case OP_vkCmdTraceRaysNV: {
             return "OP_vkCmdTraceRaysNV";
         }
 #endif
+#ifdef VK_EXT_opacity_micromap
+        case OP_vkCmdWriteMicromapsPropertiesEXT: {
+            return "OP_vkCmdWriteMicromapsPropertiesEXT";
+        }
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+        case OP_vkCmdDrawClusterIndirectHUAWEI: {
+            return "OP_vkCmdDrawClusterIndirectHUAWEI";
+        }
+#endif
 #ifdef VK_NVX_image_view_handle
         case OP_vkGetImageViewAddressNVX: {
             return "OP_vkGetImageViewAddressNVX";
@@ -40125,11 +49593,21 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdTraceRaysKHR";
         }
 #endif
+#ifdef VK_EXT_shader_module_identifier
+        case OP_vkGetShaderModuleCreateInfoIdentifierEXT: {
+            return "OP_vkGetShaderModuleCreateInfoIdentifierEXT";
+        }
+#endif
 #ifdef VK_FUCHSIA_external_memory
         case OP_vkGetMemoryZirconHandleFUCHSIA: {
             return "OP_vkGetMemoryZirconHandleFUCHSIA";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdCopyImageToBuffer2: {
+            return "OP_vkCmdCopyImageToBuffer2";
+        }
+#endif
 #ifdef VK_NV_shading_rate_image
         case OP_vkCmdSetViewportShadingRatePaletteNV: {
             return "OP_vkCmdSetViewportShadingRatePaletteNV";
@@ -40145,6 +49623,14 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkBindVideoSessionMemoryKHR";
         }
 #endif
+#ifdef VK_NV_optical_flow
+        case OP_vkBindOpticalFlowSessionImageNV: {
+            return "OP_vkBindOpticalFlowSessionImageNV";
+        }
+        case OP_vkCmdOpticalFlowExecuteNV: {
+            return "OP_vkCmdOpticalFlowExecuteNV";
+        }
+#endif
 #ifdef VK_KHR_deferred_host_operations
         case OP_vkDeferredOperationJoinKHR: {
             return "OP_vkDeferredOperationJoinKHR";
@@ -40160,16 +49646,31 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkGetBufferDeviceAddressKHR";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdSetDepthBoundsTestEnable: {
+            return "OP_vkCmdSetDepthBoundsTestEnable";
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case OP_vkGetAccelerationStructureBuildSizesKHR: {
             return "OP_vkGetAccelerationStructureBuildSizesKHR";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdSetScissorWithCount: {
+            return "OP_vkCmdSetScissorWithCount";
+        }
+#endif
 #ifdef VK_NVX_binary_import
         case OP_vkCmdCuLaunchKernelNVX: {
             return "OP_vkCmdCuLaunchKernelNVX";
         }
 #endif
+#ifdef VK_NV_memory_decompression
+        case OP_vkCmdDecompressMemoryNV: {
+            return "OP_vkCmdDecompressMemoryNV";
+        }
+#endif
 #ifdef VK_NV_ray_tracing
         case OP_vkGetAccelerationStructureMemoryRequirementsNV: {
             return "OP_vkGetAccelerationStructureMemoryRequirementsNV";
@@ -40180,6 +49681,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdSubpassShadingHUAWEI";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdEndRendering: {
+            return "OP_vkCmdEndRendering";
+        }
+#endif
 #ifdef VK_EXT_directfb_surface
         case OP_vkCreateDirectFBSurfaceEXT: {
             return "OP_vkCreateDirectFBSurfaceEXT";
@@ -40190,6 +49696,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdEndRenderPass2";
         }
 #endif
+#ifdef VK_EXT_descriptor_buffer
+        case OP_vkGetDescriptorSetLayoutBindingOffsetEXT: {
+            return "OP_vkGetDescriptorSetLayoutBindingOffsetEXT";
+        }
+#endif
 #ifdef VK_KHR_ray_tracing_pipeline
         case OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR: {
             return "OP_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR";
@@ -40200,6 +49711,16 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkGetBufferDeviceAddress";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdSetFrontFace: {
+            return "OP_vkCmdSetFrontFace";
+        }
+#endif
+#ifdef VK_EXT_discard_rectangles
+        case OP_vkCmdSetDiscardRectangleModeEXT: {
+            return "OP_vkCmdSetDiscardRectangleModeEXT";
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state
         case OP_vkCmdSetDepthBoundsTestEnableEXT: {
             return "OP_vkCmdSetDepthBoundsTestEnableEXT";
@@ -40209,10 +49730,22 @@ const char* api_opcode_to_string(const uint32_t opcode) {
         case OP_vkGetAccelerationStructureDeviceAddressKHR: {
             return "OP_vkGetAccelerationStructureDeviceAddressKHR";
         }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetColorBlendEquationEXT: {
+            return "OP_vkCmdSetColorBlendEquationEXT";
+        }
+#endif
+#ifdef VK_KHR_acceleration_structure
         case OP_vkCmdCopyAccelerationStructureToMemoryKHR: {
             return "OP_vkCmdCopyAccelerationStructureToMemoryKHR";
         }
 #endif
+#ifdef VK_EXT_mesh_shader
+        case OP_vkCmdDrawMeshTasksIndirectEXT: {
+            return "OP_vkCmdDrawMeshTasksIndirectEXT";
+        }
+#endif
 #ifdef VK_NV_mesh_shader
         case OP_vkCmdDrawMeshTasksIndirectCountNV: {
             return "OP_vkCmdDrawMeshTasksIndirectCountNV";
@@ -40243,6 +49776,14 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCreateScreenSurfaceQNX";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkDestroyPrivateDataSlot: {
+            return "OP_vkDestroyPrivateDataSlot";
+        }
+        case OP_vkCmdSetCullMode: {
+            return "OP_vkCmdSetCullMode";
+        }
+#endif
 #ifdef VK_KHR_synchronization2
         case OP_vkCmdWriteBufferMarker2AMD: {
             return "OP_vkCmdWriteBufferMarker2AMD";
@@ -40258,11 +49799,21 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkDestroyBufferCollectionFUCHSIA";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetCoverageModulationModeNV: {
+            return "OP_vkCmdSetCoverageModulationModeNV";
+        }
+#endif
 #ifdef VK_EXT_private_data
         case OP_vkSetPrivateDataEXT: {
             return "OP_vkSetPrivateDataEXT";
         }
 #endif
+#ifdef VK_EXT_descriptor_buffer
+        case OP_vkGetImageViewOpaqueCaptureDescriptorDataEXT: {
+            return "OP_vkGetImageViewOpaqueCaptureDescriptorDataEXT";
+        }
+#endif
 #ifdef VK_HUAWEI_subpass_shading
         case OP_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI: {
             return "OP_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI";
@@ -40273,6 +49824,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdSetExclusiveScissorNV";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetLineStippleEnableEXT: {
+            return "OP_vkCmdSetLineStippleEnableEXT";
+        }
+#endif
 #ifdef VK_KHR_copy_commands2
         case OP_vkCmdCopyImage2KHR: {
             return "OP_vkCmdCopyImage2KHR";
@@ -40288,11 +49844,21 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCreateVideoSessionKHR";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetColorWriteMaskEXT: {
+            return "OP_vkCmdSetColorWriteMaskEXT";
+        }
+#endif
 #ifdef VK_KHR_timeline_semaphore
         case OP_vkGetSemaphoreCounterValueKHR: {
             return "OP_vkGetSemaphoreCounterValueKHR";
         }
 #endif
+#ifdef VK_KHR_map_memory2
+        case OP_vkUnmapMemory2KHR: {
+            return "OP_vkUnmapMemory2KHR";
+        }
+#endif
 #ifdef VK_NV_ray_tracing
         case OP_vkGetRayTracingShaderGroupHandlesNV: {
             return "OP_vkGetRayTracingShaderGroupHandlesNV";
@@ -40303,11 +49869,46 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkGetBufferOpaqueCaptureAddress";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdSetPrimitiveRestartEnable: {
+            return "OP_vkCmdSetPrimitiveRestartEnable";
+        }
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+        case OP_vkReleaseSwapchainImagesEXT: {
+            return "OP_vkReleaseSwapchainImagesEXT";
+        }
+#endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdSetEvent2: {
+            return "OP_vkCmdSetEvent2";
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case OP_vkGetDescriptorSetLayoutSizeEXT: {
+            return "OP_vkGetDescriptorSetLayoutSizeEXT";
+        }
+#endif
+#ifdef VK_KHR_map_memory2
+        case OP_vkMapMemory2KHR: {
+            return "OP_vkMapMemory2KHR";
+        }
+#endif
+#ifdef VK_VERSION_1_3
+        case OP_vkGetDeviceImageSparseMemoryRequirements: {
+            return "OP_vkGetDeviceImageSparseMemoryRequirements";
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state
         case OP_vkCmdSetDepthTestEnableEXT: {
             return "OP_vkCmdSetDepthTestEnableEXT";
         }
 #endif
+#ifdef VK_EXT_opacity_micromap
+        case OP_vkCmdCopyMicromapToMemoryEXT: {
+            return "OP_vkCmdCopyMicromapToMemoryEXT";
+        }
+#endif
 #ifdef VK_NV_device_generated_commands
         case OP_vkCmdExecuteGeneratedCommandsNV: {
             return "OP_vkCmdExecuteGeneratedCommandsNV";
@@ -40318,16 +49919,31 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdBeginRenderPass2";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdSetStencilOp: {
+            return "OP_vkCmdSetStencilOp";
+        }
+#endif
 #ifdef VK_EXT_private_data
         case OP_vkCreatePrivateDataSlotEXT: {
             return "OP_vkCreatePrivateDataSlotEXT";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdCopyBuffer2: {
+            return "OP_vkCmdCopyBuffer2";
+        }
+#endif
 #ifdef VK_NV_shading_rate_image
         case OP_vkCmdSetCoarseSampleOrderNV: {
             return "OP_vkCmdSetCoarseSampleOrderNV";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkGetPrivateData: {
+            return "OP_vkGetPrivateData";
+        }
+#endif
 #ifdef VK_KHR_video_queue
         case OP_vkDestroyVideoSessionParametersKHR: {
             return "OP_vkDestroyVideoSessionParametersKHR";
@@ -40351,11 +49967,26 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdBeginVideoCodingKHR";
         }
 #endif
+#ifdef VK_QCOM_tile_properties
+        case OP_vkGetDynamicRenderingTilePropertiesQCOM: {
+            return "OP_vkGetDynamicRenderingTilePropertiesQCOM";
+        }
+#endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdSetDepthWriteEnable: {
+            return "OP_vkCmdSetDepthWriteEnable";
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case OP_vkCopyAccelerationStructureKHR: {
             return "OP_vkCopyAccelerationStructureKHR";
         }
 #endif
+#ifdef VK_EXT_opacity_micromap
+        case OP_vkBuildMicromapsEXT: {
+            return "OP_vkBuildMicromapsEXT";
+        }
+#endif
 #ifdef VK_GGP_stream_descriptor_surface
         case OP_vkCreateStreamDescriptorSurfaceGGP: {
             return "OP_vkCreateStreamDescriptorSurfaceGGP";
@@ -40366,11 +49997,26 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkBuildAccelerationStructuresKHR";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkSetPrivateData: {
+            return "OP_vkSetPrivateData";
+        }
+#endif
 #ifdef VK_FUCHSIA_buffer_collection
         case OP_vkGetBufferCollectionPropertiesFUCHSIA: {
             return "OP_vkGetBufferCollectionPropertiesFUCHSIA";
         }
 #endif
+#ifdef VK_EXT_shader_object
+        case OP_vkDestroyShaderEXT: {
+            return "OP_vkDestroyShaderEXT";
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case OP_vkDestroyMicromapEXT: {
+            return "OP_vkDestroyMicromapEXT";
+        }
+#endif
 #ifdef VK_EXT_host_query_reset
         case OP_vkResetQueryPoolEXT: {
             return "OP_vkResetQueryPoolEXT";
@@ -40386,21 +50032,61 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdBindVertexBuffers2EXT";
         }
 #endif
+#ifdef VK_EXT_pipeline_properties
+        case OP_vkGetPipelinePropertiesEXT: {
+            return "OP_vkGetPipelinePropertiesEXT";
+        }
+#endif
 #ifdef VK_GOOGLE_gfxstream
         case OP_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE: {
             return "OP_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE";
         }
 #endif
+#ifdef VK_EXT_descriptor_buffer
+        case OP_vkGetImageOpaqueCaptureDescriptorDataEXT: {
+            return "OP_vkGetImageOpaqueCaptureDescriptorDataEXT";
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetPolygonModeEXT: {
+            return "OP_vkCmdSetPolygonModeEXT";
+        }
+#endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdWaitEvents2: {
+            return "OP_vkCmdWaitEvents2";
+        }
+#endif
+#ifdef VK_GOOGLE_gfxstream
+        case OP_vkUpdateDescriptorSetWithTemplateSized2GOOGLE: {
+            return "OP_vkUpdateDescriptorSetWithTemplateSized2GOOGLE";
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetRepresentativeFragmentTestEnableNV: {
+            return "OP_vkCmdSetRepresentativeFragmentTestEnableNV";
+        }
+#endif
 #ifdef VK_VERSION_1_2
         case OP_vkCmdNextSubpass2: {
             return "OP_vkCmdNextSubpass2";
         }
 #endif
+#ifdef VK_NV_copy_memory_indirect
+        case OP_vkCmdCopyMemoryIndirectNV: {
+            return "OP_vkCmdCopyMemoryIndirectNV";
+        }
+#endif
 #ifdef VK_KHR_synchronization2
         case OP_vkCmdWaitEvents2KHR: {
             return "OP_vkCmdWaitEvents2KHR";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetCoverageToColorLocationNV: {
+            return "OP_vkCmdSetCoverageToColorLocationNV";
+        }
+#endif
 #ifdef VK_VERSION_1_2
         case OP_vkCmdDrawIndexedIndirectCount: {
             return "OP_vkCmdDrawIndexedIndirectCount";
@@ -40411,11 +50097,24 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdSetRasterizerDiscardEnableEXT";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdSetDepthCompareOp: {
+            return "OP_vkCmdSetDepthCompareOp";
+        }
+#endif
 #ifdef VK_INTEL_performance_query
         case OP_vkAcquirePerformanceConfigurationINTEL: {
             return "OP_vkAcquirePerformanceConfigurationINTEL";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdWriteTimestamp2: {
+            return "OP_vkCmdWriteTimestamp2";
+        }
+        case OP_vkCmdCopyImage2: {
+            return "OP_vkCmdCopyImage2";
+        }
+#endif
 #ifdef VK_KHR_ray_tracing_pipeline
         case OP_vkCreateRayTracingPipelinesKHR: {
             return "OP_vkCreateRayTracingPipelinesKHR";
@@ -40436,6 +50135,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkGetPhysicalDeviceVideoCapabilitiesKHR";
         }
 #endif
+#ifdef VK_QCOM_tile_properties
+        case OP_vkGetFramebufferTilePropertiesQCOM: {
+            return "OP_vkGetFramebufferTilePropertiesQCOM";
+        }
+#endif
 #ifdef VK_FUCHSIA_external_semaphore
         case OP_vkGetSemaphoreZirconHandleFUCHSIA: {
             return "OP_vkGetSemaphoreZirconHandleFUCHSIA";
@@ -40456,6 +50160,14 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkAcquireDrmDisplayEXT";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetAlphaToCoverageEnableEXT: {
+            return "OP_vkCmdSetAlphaToCoverageEnableEXT";
+        }
+        case OP_vkCmdSetDepthClampEnableEXT: {
+            return "OP_vkCmdSetDepthClampEnableEXT";
+        }
+#endif
 #ifdef VK_EXT_image_drm_format_modifier
         case OP_vkGetImageDrmFormatModifierPropertiesEXT: {
             return "OP_vkGetImageDrmFormatModifierPropertiesEXT";
@@ -40466,6 +50178,16 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdSetPerformanceOverrideINTEL";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetProvokingVertexModeEXT: {
+            return "OP_vkCmdSetProvokingVertexModeEXT";
+        }
+#endif
+#ifdef VK_EXT_mesh_shader
+        case OP_vkCmdDrawMeshTasksIndirectCountEXT: {
+            return "OP_vkCmdDrawMeshTasksIndirectCountEXT";
+        }
+#endif
 #ifdef VK_VERSION_1_2
         case OP_vkResetQueryPool: {
             return "OP_vkResetQueryPool";
@@ -40501,6 +50223,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkDestroyCuFunctionNVX";
         }
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+        case OP_vkCmdDrawClusterHUAWEI: {
+            return "OP_vkCmdDrawClusterHUAWEI";
+        }
+#endif
 #ifdef VK_KHR_copy_commands2
         case OP_vkCmdResolveImage2KHR: {
             return "OP_vkCmdResolveImage2KHR";
@@ -40511,6 +50238,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCreateMetalSurfaceEXT";
         }
 #endif
+#ifdef VK_NV_optical_flow
+        case OP_vkDestroyOpticalFlowSessionNV: {
+            return "OP_vkDestroyOpticalFlowSessionNV";
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case OP_vkCopyAccelerationStructureToMemoryKHR: {
             return "OP_vkCopyAccelerationStructureToMemoryKHR";
@@ -40546,6 +50278,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkGetPhysicalDeviceScreenPresentationSupportQNX";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdBindVertexBuffers2: {
+            return "OP_vkCmdBindVertexBuffers2";
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case OP_vkCreateAccelerationStructureKHR: {
             return "OP_vkCreateAccelerationStructureKHR";
@@ -40556,11 +50293,26 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdSetDepthBiasEnableEXT";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetCoverageReductionModeNV: {
+            return "OP_vkCmdSetCoverageReductionModeNV";
+        }
+#endif
 #ifdef VK_NV_ray_tracing
         case OP_vkCreateAccelerationStructureNV: {
             return "OP_vkCreateAccelerationStructureNV";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetCoverageModulationTableNV: {
+            return "OP_vkCmdSetCoverageModulationTableNV";
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case OP_vkCreateMicromapEXT: {
+            return "OP_vkCreateMicromapEXT";
+        }
+#endif
 #ifdef VK_KHR_copy_commands2
         case OP_vkCmdBlitImage2KHR: {
             return "OP_vkCmdBlitImage2KHR";
@@ -40581,6 +50333,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdSetPrimitiveTopologyEXT";
         }
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+        case OP_vkCmdTraceRaysIndirect2KHR: {
+            return "OP_vkCmdTraceRaysIndirect2KHR";
+        }
+#endif
 #ifdef VK_KHR_video_queue
         case OP_vkUpdateVideoSessionParametersKHR: {
             return "OP_vkUpdateVideoSessionParametersKHR";
@@ -40606,6 +50363,19 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkGetPhysicalDeviceVideoFormatPropertiesKHR";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetViewportSwizzleNV: {
+            return "OP_vkCmdSetViewportSwizzleNV";
+        }
+#endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCreatePrivateDataSlot: {
+            return "OP_vkCreatePrivateDataSlot";
+        }
+        case OP_vkCmdSetPrimitiveTopology: {
+            return "OP_vkCmdSetPrimitiveTopology";
+        }
+#endif
 #ifdef VK_KHR_present_wait
         case OP_vkWaitForPresentKHR: {
             return "OP_vkWaitForPresentKHR";
@@ -40636,6 +50406,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdSetFragmentShadingRateEnumNV";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetTessellationDomainOriginEXT: {
+            return "OP_vkCmdSetTessellationDomainOriginEXT";
+        }
+#endif
 #ifdef VK_KHR_video_queue
         case OP_vkCreateVideoSessionParametersKHR: {
             return "OP_vkCreateVideoSessionParametersKHR";
@@ -40656,6 +50431,21 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkGetSemaphoreCounterValue";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdSetDepthBiasEnable: {
+            return "OP_vkCmdSetDepthBiasEnable";
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case OP_vkCopyMicromapToMemoryEXT: {
+            return "OP_vkCopyMicromapToMemoryEXT";
+        }
+#endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdSetViewportWithCount: {
+            return "OP_vkCmdSetViewportWithCount";
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
         case OP_vkCmdSetLogicOpEXT: {
             return "OP_vkCmdSetLogicOpEXT";
@@ -40676,21 +50466,41 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkQueueCommitDescriptorSetUpdatesGOOGLE";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdCopyBufferToImage2: {
+            return "OP_vkCmdCopyBufferToImage2";
+        }
+#endif
 #ifdef VK_EXT_full_screen_exclusive
         case OP_vkGetPhysicalDeviceSurfacePresentModes2EXT: {
             return "OP_vkGetPhysicalDeviceSurfacePresentModes2EXT";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetSampleLocationsEnableEXT: {
+            return "OP_vkCmdSetSampleLocationsEnableEXT";
+        }
+#endif
 #ifdef VK_NV_ray_tracing
         case OP_vkCmdBuildAccelerationStructureNV: {
             return "OP_vkCmdBuildAccelerationStructureNV";
         }
 #endif
+#ifdef VK_EXT_descriptor_buffer
+        case OP_vkCmdBindDescriptorBuffersEXT: {
+            return "OP_vkCmdBindDescriptorBuffersEXT";
+        }
+#endif
 #ifdef VK_KHR_pipeline_executable_properties
         case OP_vkGetPipelineExecutablePropertiesKHR: {
             return "OP_vkGetPipelineExecutablePropertiesKHR";
         }
 #endif
+#ifdef VK_EXT_shader_object
+        case OP_vkCmdBindShadersEXT: {
+            return "OP_vkCmdBindShadersEXT";
+        }
+#endif
 #ifdef VK_NV_ray_tracing
         case OP_vkGetAccelerationStructureHandleNV: {
             return "OP_vkGetAccelerationStructureHandleNV";
@@ -40716,16 +50526,31 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdSetEvent2KHR";
         }
 #endif
+#ifdef VK_EXT_opacity_micromap
+        case OP_vkCopyMicromapEXT: {
+            return "OP_vkCopyMicromapEXT";
+        }
+#endif
 #ifdef VK_VERSION_1_2
         case OP_vkSignalSemaphore: {
             return "OP_vkSignalSemaphore";
         }
 #endif
+#ifdef VK_EXT_descriptor_buffer
+        case OP_vkCmdSetDescriptorBufferOffsetsEXT: {
+            return "OP_vkCmdSetDescriptorBufferOffsetsEXT";
+        }
+#endif
 #ifdef VK_KHR_pipeline_executable_properties
         case OP_vkGetPipelineExecutableStatisticsKHR: {
             return "OP_vkGetPipelineExecutableStatisticsKHR";
         }
 #endif
+#ifdef VK_EXT_shader_object
+        case OP_vkGetShaderBinaryDataEXT: {
+            return "OP_vkGetShaderBinaryDataEXT";
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case OP_vkCmdWriteAccelerationStructuresPropertiesKHR: {
             return "OP_vkCmdWriteAccelerationStructuresPropertiesKHR";
@@ -40736,6 +50561,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkGetRayTracingShaderGroupHandlesKHR";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdResetEvent2: {
+            return "OP_vkCmdResetEvent2";
+        }
+#endif
 #ifdef VK_EXT_transform_feedback
         case OP_vkCmdEndTransformFeedbackEXT: {
             return "OP_vkCmdEndTransformFeedbackEXT";
@@ -40756,6 +50586,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkDestroyCuModuleNVX";
         }
 #endif
+#ifdef VK_EXT_descriptor_buffer
+        case OP_vkGetSamplerOpaqueCaptureDescriptorDataEXT: {
+            return "OP_vkGetSamplerOpaqueCaptureDescriptorDataEXT";
+        }
+#endif
 #ifdef VK_NV_mesh_shader
         case OP_vkCmdDrawMeshTasksIndirectNV: {
             return "OP_vkCmdDrawMeshTasksIndirectNV";
@@ -40776,11 +50611,24 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCreateDeferredOperationKHR";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetCoverageToColorEnableNV: {
+            return "OP_vkCmdSetCoverageToColorEnableNV";
+        }
+#endif
 #ifdef VK_FUCHSIA_buffer_collection
         case OP_vkSetBufferCollectionImageConstraintsFUCHSIA: {
             return "OP_vkSetBufferCollectionImageConstraintsFUCHSIA";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdBlitImage2: {
+            return "OP_vkCmdBlitImage2";
+        }
+        case OP_vkQueueSubmit2: {
+            return "OP_vkQueueSubmit2";
+        }
+#endif
 #ifdef VK_KHR_maintenance4
         case OP_vkGetDeviceImageSparseMemoryRequirementsKHR: {
             return "OP_vkGetDeviceImageSparseMemoryRequirementsKHR";
@@ -40796,6 +50644,16 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdBeginQueryIndexedEXT";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdSetRasterizerDiscardEnable: {
+            return "OP_vkCmdSetRasterizerDiscardEnable";
+        }
+#endif
+#ifdef VK_NV_copy_memory_indirect
+        case OP_vkCmdCopyMemoryToImageIndirectNV: {
+            return "OP_vkCmdCopyMemoryToImageIndirectNV";
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state
         case OP_vkCmdSetStencilOpEXT: {
             return "OP_vkCmdSetStencilOpEXT";
@@ -40806,11 +50664,26 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCreateBufferCollectionFUCHSIA";
         }
 #endif
+#ifdef VK_EXT_metal_objects
+        case OP_vkExportMetalObjectsEXT: {
+            return "OP_vkExportMetalObjectsEXT";
+        }
+#endif
 #ifdef VK_NV_ray_tracing
         case OP_vkCompileDeferredNV: {
             return "OP_vkCompileDeferredNV";
         }
 #endif
+#ifdef VK_EXT_device_fault
+        case OP_vkGetDeviceFaultInfoEXT: {
+            return "OP_vkGetDeviceFaultInfoEXT";
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetDepthClipNegativeOneToOneEXT: {
+            return "OP_vkCmdSetDepthClipNegativeOneToOneEXT";
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case OP_vkCmdCopyAccelerationStructureKHR: {
             return "OP_vkCmdCopyAccelerationStructureKHR";
@@ -40831,6 +50704,26 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdEndVideoCodingKHR";
         }
 #endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+        case OP_vkGetDescriptorSetHostMappingVALVE: {
+            return "OP_vkGetDescriptorSetHostMappingVALVE";
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case OP_vkGetBufferOpaqueCaptureDescriptorDataEXT: {
+            return "OP_vkGetBufferOpaqueCaptureDescriptorDataEXT";
+        }
+#endif
+#ifdef VK_EXT_shader_object
+        case OP_vkCreateShadersEXT: {
+            return "OP_vkCreateShadersEXT";
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case OP_vkCmdCopyMemoryToMicromapEXT: {
+            return "OP_vkCmdCopyMemoryToMicromapEXT";
+        }
+#endif
 #ifdef VK_KHR_performance_query
         case OP_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR: {
             return "OP_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR";
@@ -40846,6 +50739,14 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkGetLinearImageLayout2GOOGLE";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdResolveImage2: {
+            return "OP_vkCmdResolveImage2";
+        }
+        case OP_vkGetDeviceImageMemoryRequirements: {
+            return "OP_vkGetDeviceImageMemoryRequirements";
+        }
+#endif
 #ifdef VK_EXT_acquire_drm_display
         case OP_vkGetDrmDisplayEXT: {
             return "OP_vkGetDrmDisplayEXT";
@@ -40856,11 +50757,36 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdDrawIndirectCount";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetLogicOpEnableEXT: {
+            return "OP_vkCmdSetLogicOpEnableEXT";
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case OP_vkGetDeviceMicromapCompatibilityEXT: {
+            return "OP_vkGetDeviceMicromapCompatibilityEXT";
+        }
+#endif
 #ifdef VK_KHR_synchronization2
         case OP_vkCmdResetEvent2KHR: {
             return "OP_vkCmdResetEvent2KHR";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetDepthClipEnableEXT: {
+            return "OP_vkCmdSetDepthClipEnableEXT";
+        }
+#endif
+#ifdef VK_EXT_discard_rectangles
+        case OP_vkCmdSetDiscardRectangleEnableEXT: {
+            return "OP_vkCmdSetDiscardRectangleEnableEXT";
+        }
+#endif
+#ifdef VK_NV_memory_decompression
+        case OP_vkCmdDecompressMemoryIndirectCountNV: {
+            return "OP_vkCmdDecompressMemoryIndirectCountNV";
+        }
+#endif
 #ifdef VK_EXT_multi_draw
         case OP_vkCmdDrawMultiIndexedEXT: {
             return "OP_vkCmdDrawMultiIndexedEXT";
@@ -40876,6 +50802,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCreateIndirectCommandsLayoutNV";
         }
 #endif
+#ifdef VK_EXT_mesh_shader
+        case OP_vkCmdDrawMeshTasksEXT: {
+            return "OP_vkCmdDrawMeshTasksEXT";
+        }
+#endif
 #ifdef VK_EXT_directfb_surface
         case OP_vkGetPhysicalDeviceDirectFBPresentationSupportEXT: {
             return "OP_vkGetPhysicalDeviceDirectFBPresentationSupportEXT";
@@ -40886,31 +50817,94 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkGetBufferOpaqueCaptureAddressKHR";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetCoverageModulationTableEnableNV: {
+            return "OP_vkCmdSetCoverageModulationTableEnableNV";
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state
         case OP_vkCmdSetStencilTestEnableEXT: {
             return "OP_vkCmdSetStencilTestEnableEXT";
         }
 #endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+        case OP_vkCmdSetAttachmentFeedbackLoopEnableEXT: {
+            return "OP_vkCmdSetAttachmentFeedbackLoopEnableEXT";
+        }
+#endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdSetStencilTestEnable: {
+            return "OP_vkCmdSetStencilTestEnable";
+        }
+        case OP_vkGetPhysicalDeviceToolProperties: {
+            return "OP_vkGetPhysicalDeviceToolProperties";
+        }
+#endif
 #ifdef VK_NV_cooperative_matrix
         case OP_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV: {
             return "OP_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV";
         }
 #endif
+#ifdef VK_ANDROID_native_buffer
+        case OP_vkGetSwapchainGrallocUsage2ANDROID: {
+            return "OP_vkGetSwapchainGrallocUsage2ANDROID";
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case OP_vkCmdCopyMicromapEXT: {
+            return "OP_vkCmdCopyMicromapEXT";
+        }
+#endif
+#ifdef VK_EXT_shader_module_identifier
+        case OP_vkGetShaderModuleIdentifierEXT: {
+            return "OP_vkGetShaderModuleIdentifierEXT";
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case OP_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT: {
+            return "OP_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT";
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case OP_vkWriteAccelerationStructuresPropertiesKHR: {
             return "OP_vkWriteAccelerationStructuresPropertiesKHR";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetAlphaToOneEnableEXT: {
+            return "OP_vkCmdSetAlphaToOneEnableEXT";
+        }
+#endif
 #ifdef VK_GOOGLE_gfxstream
         case OP_vkQueueFlushCommandsFromAuxMemoryGOOGLE: {
             return "OP_vkQueueFlushCommandsFromAuxMemoryGOOGLE";
         }
 #endif
+#ifdef VK_EXT_opacity_micromap
+        case OP_vkGetMicromapBuildSizesEXT: {
+            return "OP_vkGetMicromapBuildSizesEXT";
+        }
+#endif
+#ifdef VK_NV_scissor_exclusive
+        case OP_vkCmdSetExclusiveScissorEnableNV: {
+            return "OP_vkCmdSetExclusiveScissorEnableNV";
+        }
+#endif
+#ifdef VK_NV_optical_flow
+        case OP_vkGetPhysicalDeviceOpticalFlowImageFormatsNV: {
+            return "OP_vkGetPhysicalDeviceOpticalFlowImageFormatsNV";
+        }
+#endif
 #ifdef VK_EXT_private_data
         case OP_vkGetPrivateDataEXT: {
             return "OP_vkGetPrivateDataEXT";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetExtraPrimitiveOverestimationSizeEXT: {
+            return "OP_vkCmdSetExtraPrimitiveOverestimationSizeEXT";
+        }
+#endif
 #ifdef VK_NV_coverage_reduction_mode
         case OP_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV: {
             return "OP_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV";
@@ -40921,6 +50915,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkGetQueueCheckpointData2NV";
         }
 #endif
+#ifdef VK_EXT_opacity_micromap
+        case OP_vkCopyMemoryToMicromapEXT: {
+            return "OP_vkCopyMemoryToMicromapEXT";
+        }
+#endif
 #ifdef VK_NV_device_generated_commands
         case OP_vkDestroyIndirectCommandsLayoutNV: {
             return "OP_vkDestroyIndirectCommandsLayoutNV";
@@ -40931,6 +50930,19 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkQueueSubmit2KHR";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetConservativeRasterizationModeEXT: {
+            return "OP_vkCmdSetConservativeRasterizationModeEXT";
+        }
+        case OP_vkCmdSetLineRasterizationModeEXT: {
+            return "OP_vkCmdSetLineRasterizationModeEXT";
+        }
+#endif
+#ifdef VK_VERSION_1_3
+        case OP_vkGetDeviceBufferMemoryRequirements: {
+            return "OP_vkGetDeviceBufferMemoryRequirements";
+        }
+#endif
 #ifdef VK_NV_acquire_winrt_display
         case OP_vkGetWinrtDisplayNV: {
             return "OP_vkGetWinrtDisplayNV";
@@ -40941,6 +50953,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdBeginTransformFeedbackEXT";
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdBeginRendering: {
+            return "OP_vkCmdBeginRendering";
+        }
+#endif
 #ifdef VK_KHR_buffer_device_address
         case OP_vkGetDeviceMemoryOpaqueCaptureAddressKHR: {
             return "OP_vkGetDeviceMemoryOpaqueCaptureAddressKHR";
@@ -40951,6 +50968,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkQueueSetPerformanceConfigurationINTEL";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetColorBlendEnableEXT: {
+            return "OP_vkCmdSetColorBlendEnableEXT";
+        }
+#endif
 #ifdef VK_EXT_calibrated_timestamps
         case OP_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT: {
             return "OP_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT";
@@ -40966,6 +50988,21 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkUninitializePerformanceApiINTEL";
         }
 #endif
+#ifdef VK_EXT_image_compression_control
+        case OP_vkGetImageSubresourceLayout2EXT: {
+            return "OP_vkGetImageSubresourceLayout2EXT";
+        }
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+        case OP_vkGetDescriptorSetLayoutHostMappingInfoVALVE: {
+            return "OP_vkGetDescriptorSetLayoutHostMappingInfoVALVE";
+        }
+#endif
+#ifdef VK_VERSION_1_3
+        case OP_vkCmdPipelineBarrier2: {
+            return "OP_vkCmdPipelineBarrier2";
+        }
+#endif
 #ifdef VK_NV_device_generated_commands
         case OP_vkCmdPreprocessGeneratedCommandsNV: {
             return "OP_vkCmdPreprocessGeneratedCommandsNV";
@@ -41001,6 +51038,11 @@ const char* api_opcode_to_string(const uint32_t opcode) {
             return "OP_vkCmdSetPrimitiveRestartEnableEXT";
         }
 #endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case OP_vkCmdSetShadingRateImageEnableNV: {
+            return "OP_vkCmdSetShadingRateImageEnableNV";
+        }
+#endif
         default: {
             return "OP_UNKNOWN_API_CALL";
         }
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_marshaling.h b/stream-servers/vulkan/cereal/common/goldfish_vk_marshaling.h
index a9455a8c..56ef57aa 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_marshaling.h
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_marshaling.h
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_marshaling
 //
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (header) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -1758,6 +1758,413 @@ void unmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
 #define OP_vkGetBufferOpaqueCaptureAddress 230188231
 #define OP_vkGetDeviceMemoryOpaqueCaptureAddress 260620079
 #endif
+#ifdef VK_VERSION_1_3
+void marshal_VkPhysicalDeviceVulkan13Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceVulkan13Features* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceVulkan13Features(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkPhysicalDeviceVulkan13Features* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceVulkan13Properties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceVulkan13Properties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceVulkan13Properties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceVulkan13Properties* forUnmarshaling);
+
+void marshal_VkPipelineCreationFeedback(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkPipelineCreationFeedback* forMarshaling);
+
+void unmarshal_VkPipelineCreationFeedback(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkPipelineCreationFeedback* forUnmarshaling);
+
+void marshal_VkPipelineCreationFeedbackCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelineCreationFeedbackCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineCreationFeedbackCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineCreationFeedbackCreateInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderTerminateInvocationFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderTerminateInvocationFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceToolProperties(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkPhysicalDeviceToolProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceToolProperties(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkPhysicalDeviceToolProperties* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceToolProperties 286895278
+void marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDevicePrivateDataFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePrivateDataFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePrivateDataFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePrivateDataFeatures* forUnmarshaling);
+
+void marshal_VkDevicePrivateDataCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkDevicePrivateDataCreateInfo* forMarshaling);
+
+void unmarshal_VkDevicePrivateDataCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkDevicePrivateDataCreateInfo* forUnmarshaling);
+
+void marshal_VkPrivateDataSlotCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkPrivateDataSlotCreateInfo* forMarshaling);
+
+void unmarshal_VkPrivateDataSlotCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkPrivateDataSlotCreateInfo* forUnmarshaling);
+
+#define OP_vkCreatePrivateDataSlot 262776916
+#define OP_vkDestroyPrivateDataSlot 224520231
+#define OP_vkSetPrivateData 242146991
+#define OP_vkGetPrivateData 237052348
+void marshal_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePipelineCreationCacheControlFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineCreationCacheControlFeatures* forUnmarshaling);
+
+void marshal_VkMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                              const VkMemoryBarrier2* forMarshaling);
+
+void unmarshal_VkMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                VkMemoryBarrier2* forUnmarshaling);
+
+void marshal_VkBufferMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkBufferMemoryBarrier2* forMarshaling);
+
+void unmarshal_VkBufferMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkBufferMemoryBarrier2* forUnmarshaling);
+
+void marshal_VkImageMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                   const VkImageMemoryBarrier2* forMarshaling);
+
+void unmarshal_VkImageMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkImageMemoryBarrier2* forUnmarshaling);
+
+void marshal_VkDependencyInfo(VulkanStream* vkStream, VkStructureType rootType,
+                              const VkDependencyInfo* forMarshaling);
+
+void unmarshal_VkDependencyInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                VkDependencyInfo* forUnmarshaling);
+
+void marshal_VkSemaphoreSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                   const VkSemaphoreSubmitInfo* forMarshaling);
+
+void unmarshal_VkSemaphoreSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkSemaphoreSubmitInfo* forUnmarshaling);
+
+void marshal_VkCommandBufferSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                       const VkCommandBufferSubmitInfo* forMarshaling);
+
+void unmarshal_VkCommandBufferSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkCommandBufferSubmitInfo* forUnmarshaling);
+
+void marshal_VkSubmitInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                           const VkSubmitInfo2* forMarshaling);
+
+void unmarshal_VkSubmitInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                             VkSubmitInfo2* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceSynchronization2Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceSynchronization2Features* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSynchronization2Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSynchronization2Features* forUnmarshaling);
+
+#define OP_vkCmdSetEvent2 232259114
+#define OP_vkCmdResetEvent2 271973131
+#define OP_vkCmdWaitEvents2 244672720
+#define OP_vkCmdPipelineBarrier2 296709912
+#define OP_vkCmdWriteTimestamp2 246322283
+#define OP_vkQueueSubmit2 275454371
+void marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceImageRobustnessFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceImageRobustnessFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceImageRobustnessFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageRobustnessFeatures* forUnmarshaling);
+
+void marshal_VkBufferCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                           const VkBufferCopy2* forMarshaling);
+
+void unmarshal_VkBufferCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                             VkBufferCopy2* forUnmarshaling);
+
+void marshal_VkCopyBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                               const VkCopyBufferInfo2* forMarshaling);
+
+void unmarshal_VkCopyBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                 VkCopyBufferInfo2* forUnmarshaling);
+
+void marshal_VkImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                          const VkImageCopy2* forMarshaling);
+
+void unmarshal_VkImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                            VkImageCopy2* forUnmarshaling);
+
+void marshal_VkCopyImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                              const VkCopyImageInfo2* forMarshaling);
+
+void unmarshal_VkCopyImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                VkCopyImageInfo2* forUnmarshaling);
+
+void marshal_VkBufferImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                                const VkBufferImageCopy2* forMarshaling);
+
+void unmarshal_VkBufferImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                                  VkBufferImageCopy2* forUnmarshaling);
+
+void marshal_VkCopyBufferToImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                      const VkCopyBufferToImageInfo2* forMarshaling);
+
+void unmarshal_VkCopyBufferToImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkCopyBufferToImageInfo2* forUnmarshaling);
+
+void marshal_VkCopyImageToBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                      const VkCopyImageToBufferInfo2* forMarshaling);
+
+void unmarshal_VkCopyImageToBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkCopyImageToBufferInfo2* forUnmarshaling);
+
+void marshal_VkImageBlit2(VulkanStream* vkStream, VkStructureType rootType,
+                          const VkImageBlit2* forMarshaling);
+
+void unmarshal_VkImageBlit2(VulkanStream* vkStream, VkStructureType rootType,
+                            VkImageBlit2* forUnmarshaling);
+
+void marshal_VkBlitImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                              const VkBlitImageInfo2* forMarshaling);
+
+void unmarshal_VkBlitImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                VkBlitImageInfo2* forUnmarshaling);
+
+void marshal_VkImageResolve2(VulkanStream* vkStream, VkStructureType rootType,
+                             const VkImageResolve2* forMarshaling);
+
+void unmarshal_VkImageResolve2(VulkanStream* vkStream, VkStructureType rootType,
+                               VkImageResolve2* forUnmarshaling);
+
+void marshal_VkResolveImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                 const VkResolveImageInfo2* forMarshaling);
+
+void unmarshal_VkResolveImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                   VkResolveImageInfo2* forUnmarshaling);
+
+#define OP_vkCmdCopyBuffer2 236505336
+#define OP_vkCmdCopyImage2 247540368
+#define OP_vkCmdCopyBufferToImage2 267966219
+#define OP_vkCmdCopyImageToBuffer2 215156661
+#define OP_vkCmdBlitImage2 275239053
+#define OP_vkCmdResolveImage2 282440329
+void marshal_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceSubgroupSizeControlFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSubgroupSizeControlFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceSubgroupSizeControlProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceSubgroupSizeControlProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSubgroupSizeControlProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSubgroupSizeControlProperties* forUnmarshaling);
+
+void marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceInlineUniformBlockFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceInlineUniformBlockFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceInlineUniformBlockFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceInlineUniformBlockFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceInlineUniformBlockProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceInlineUniformBlockProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceInlineUniformBlockProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceInlineUniformBlockProperties* forUnmarshaling);
+
+void marshal_VkWriteDescriptorSetInlineUniformBlock(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkWriteDescriptorSetInlineUniformBlock* forMarshaling);
+
+void unmarshal_VkWriteDescriptorSetInlineUniformBlock(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkWriteDescriptorSetInlineUniformBlock* forUnmarshaling);
+
+void marshal_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDescriptorPoolInlineUniformBlockCreateInfo* forMarshaling);
+
+void unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorPoolInlineUniformBlockCreateInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* forUnmarshaling);
+
+void marshal_VkRenderingAttachmentInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                       const VkRenderingAttachmentInfo* forMarshaling);
+
+void unmarshal_VkRenderingAttachmentInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkRenderingAttachmentInfo* forUnmarshaling);
+
+void marshal_VkRenderingInfo(VulkanStream* vkStream, VkStructureType rootType,
+                             const VkRenderingInfo* forMarshaling);
+
+void unmarshal_VkRenderingInfo(VulkanStream* vkStream, VkStructureType rootType,
+                               VkRenderingInfo* forUnmarshaling);
+
+void marshal_VkPipelineRenderingCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkPipelineRenderingCreateInfo* forMarshaling);
+
+void unmarshal_VkPipelineRenderingCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkPipelineRenderingCreateInfo* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceDynamicRenderingFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDynamicRenderingFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDynamicRenderingFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDynamicRenderingFeatures* forUnmarshaling);
+
+void marshal_VkCommandBufferInheritanceRenderingInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkCommandBufferInheritanceRenderingInfo* forMarshaling);
+
+void unmarshal_VkCommandBufferInheritanceRenderingInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkCommandBufferInheritanceRenderingInfo* forUnmarshaling);
+
+#define OP_vkCmdBeginRendering 294618673
+#define OP_vkCmdEndRendering 220725158
+#define OP_vkCmdSetCullMode 224605861
+#define OP_vkCmdSetFrontFace 223122493
+#define OP_vkCmdSetPrimitiveTopology 263054804
+#define OP_vkCmdSetViewportWithCount 267390210
+#define OP_vkCmdSetScissorWithCount 219934891
+#define OP_vkCmdBindVertexBuffers2 258656493
+#define OP_vkCmdSetDepthTestEnable 209714588
+#define OP_vkCmdSetDepthWriteEnable 240260392
+#define OP_vkCmdSetDepthCompareOp 245341736
+#define OP_vkCmdSetDepthBoundsTestEnable 219709826
+#define OP_vkCmdSetStencilTestEnable 286845216
+#define OP_vkCmdSetStencilOp 235751186
+void marshal_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderIntegerDotProductFeatures* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderIntegerDotProductFeatures* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderIntegerDotProductProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderIntegerDotProductProperties* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceTexelBufferAlignmentProperties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceTexelBufferAlignmentProperties* forUnmarshaling);
+
+void marshal_VkFormatProperties3(VulkanStream* vkStream, VkStructureType rootType,
+                                 const VkFormatProperties3* forMarshaling);
+
+void unmarshal_VkFormatProperties3(VulkanStream* vkStream, VkStructureType rootType,
+                                   VkFormatProperties3* forUnmarshaling);
+
+#define OP_vkCmdSetRasterizerDiscardEnable 276298238
+#define OP_vkCmdSetDepthBiasEnable 267154733
+#define OP_vkCmdSetPrimitiveRestartEnable 230252008
+void marshal_VkPhysicalDeviceMaintenance4Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMaintenance4Features* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMaintenance4Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance4Features* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMaintenance4Properties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMaintenance4Properties* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMaintenance4Properties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance4Properties* forUnmarshaling);
+
+void marshal_VkDeviceBufferMemoryRequirements(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDeviceBufferMemoryRequirements* forMarshaling);
+
+void unmarshal_VkDeviceBufferMemoryRequirements(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkDeviceBufferMemoryRequirements* forUnmarshaling);
+
+void marshal_VkDeviceImageMemoryRequirements(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkDeviceImageMemoryRequirements* forMarshaling);
+
+void unmarshal_VkDeviceImageMemoryRequirements(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkDeviceImageMemoryRequirements* forUnmarshaling);
+
+#define OP_vkGetDeviceBufferMemoryRequirements 294177590
+#define OP_vkGetDeviceImageMemoryRequirements 282480635
+#define OP_vkGetDeviceImageSparseMemoryRequirements 233707261
+#endif
 #ifdef VK_KHR_surface
 void marshal_VkSurfaceCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                       const VkSurfaceCapabilitiesKHR* forMarshaling);
@@ -1954,24 +2361,31 @@ void unmarshal_VkWin32SurfaceCreateInfoKHR(VulkanStream* vkStream, VkStructureTy
 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
 #endif
 #ifdef VK_KHR_video_queue
-void marshal_VkVideoQueueFamilyProperties2KHR(
+void marshal_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkQueueFamilyQueryResultStatusPropertiesKHR* forMarshaling);
+
+void unmarshal_VkQueueFamilyQueryResultStatusPropertiesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoQueueFamilyProperties2KHR* forMarshaling);
+    VkQueueFamilyQueryResultStatusPropertiesKHR* forUnmarshaling);
 
-void unmarshal_VkVideoQueueFamilyProperties2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkVideoQueueFamilyProperties2KHR* forUnmarshaling);
+void marshal_VkQueueFamilyVideoPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkQueueFamilyVideoPropertiesKHR* forMarshaling);
 
-void marshal_VkVideoProfileKHR(VulkanStream* vkStream, VkStructureType rootType,
-                               const VkVideoProfileKHR* forMarshaling);
+void unmarshal_VkQueueFamilyVideoPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkQueueFamilyVideoPropertiesKHR* forUnmarshaling);
 
-void unmarshal_VkVideoProfileKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                 VkVideoProfileKHR* forUnmarshaling);
+void marshal_VkVideoProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                   const VkVideoProfileInfoKHR* forMarshaling);
 
-void marshal_VkVideoProfilesKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                const VkVideoProfilesKHR* forMarshaling);
+void unmarshal_VkVideoProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkVideoProfileInfoKHR* forUnmarshaling);
 
-void unmarshal_VkVideoProfilesKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                  VkVideoProfilesKHR* forUnmarshaling);
+void marshal_VkVideoProfileListInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                       const VkVideoProfileListInfoKHR* forMarshaling);
+
+void unmarshal_VkVideoProfileListInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkVideoProfileListInfoKHR* forUnmarshaling);
 
 void marshal_VkVideoCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                     const VkVideoCapabilitiesKHR* forMarshaling);
@@ -1993,29 +2407,31 @@ void marshal_VkVideoFormatPropertiesKHR(VulkanStream* vkStream, VkStructureType
 void unmarshal_VkVideoFormatPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                           VkVideoFormatPropertiesKHR* forUnmarshaling);
 
-void marshal_VkVideoPictureResourceKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                       const VkVideoPictureResourceKHR* forMarshaling);
+void marshal_VkVideoPictureResourceInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkVideoPictureResourceInfoKHR* forMarshaling);
 
-void unmarshal_VkVideoPictureResourceKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                         VkVideoPictureResourceKHR* forUnmarshaling);
+void unmarshal_VkVideoPictureResourceInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkVideoPictureResourceInfoKHR* forUnmarshaling);
 
-void marshal_VkVideoReferenceSlotKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                     const VkVideoReferenceSlotKHR* forMarshaling);
+void marshal_VkVideoReferenceSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkVideoReferenceSlotInfoKHR* forMarshaling);
 
-void unmarshal_VkVideoReferenceSlotKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                       VkVideoReferenceSlotKHR* forUnmarshaling);
+void unmarshal_VkVideoReferenceSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkVideoReferenceSlotInfoKHR* forUnmarshaling);
 
-void marshal_VkVideoGetMemoryPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           const VkVideoGetMemoryPropertiesKHR* forMarshaling);
+void marshal_VkVideoSessionMemoryRequirementsKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoSessionMemoryRequirementsKHR* forMarshaling);
 
-void unmarshal_VkVideoGetMemoryPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                             VkVideoGetMemoryPropertiesKHR* forUnmarshaling);
+void unmarshal_VkVideoSessionMemoryRequirementsKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoSessionMemoryRequirementsKHR* forUnmarshaling);
 
-void marshal_VkVideoBindMemoryKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                  const VkVideoBindMemoryKHR* forMarshaling);
+void marshal_VkBindVideoSessionMemoryInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkBindVideoSessionMemoryInfoKHR* forMarshaling);
 
-void unmarshal_VkVideoBindMemoryKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                    VkVideoBindMemoryKHR* forUnmarshaling);
+void unmarshal_VkBindVideoSessionMemoryInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkBindVideoSessionMemoryInfoKHR* forUnmarshaling);
 
 void marshal_VkVideoSessionCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                          const VkVideoSessionCreateInfoKHR* forMarshaling);
@@ -2071,6 +2487,18 @@ void unmarshal_VkVideoCodingControlInfoKHR(VulkanStream* vkStream, VkStructureTy
 #define OP_vkCmdControlVideoCodingKHR 252933003
 #endif
 #ifdef VK_KHR_video_decode_queue
+void marshal_VkVideoDecodeCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                          const VkVideoDecodeCapabilitiesKHR* forMarshaling);
+
+void unmarshal_VkVideoDecodeCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                            VkVideoDecodeCapabilitiesKHR* forUnmarshaling);
+
+void marshal_VkVideoDecodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                       const VkVideoDecodeUsageInfoKHR* forMarshaling);
+
+void unmarshal_VkVideoDecodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkVideoDecodeUsageInfoKHR* forUnmarshaling);
+
 void marshal_VkVideoDecodeInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                   const VkVideoDecodeInfoKHR* forMarshaling);
 
@@ -2079,41 +2507,75 @@ void unmarshal_VkVideoDecodeInfoKHR(VulkanStream* vkStream, VkStructureType root
 
 #define OP_vkCmdDecodeVideoKHR 275796951
 #endif
-#ifdef VK_KHR_dynamic_rendering
-void marshal_VkRenderingAttachmentInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                          const VkRenderingAttachmentInfoKHR* forMarshaling);
+#ifdef VK_KHR_video_decode_h264
+void marshal_VkVideoDecodeH264ProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoDecodeH264ProfileInfoKHR* forMarshaling);
 
-void unmarshal_VkRenderingAttachmentInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                            VkRenderingAttachmentInfoKHR* forUnmarshaling);
+void unmarshal_VkVideoDecodeH264ProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoDecodeH264ProfileInfoKHR* forUnmarshaling);
 
-void marshal_VkRenderingInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                const VkRenderingInfoKHR* forMarshaling);
-
-void unmarshal_VkRenderingInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                  VkRenderingInfoKHR* forUnmarshaling);
-
-void marshal_VkPipelineRenderingCreateInfoKHR(
+void marshal_VkVideoDecodeH264CapabilitiesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPipelineRenderingCreateInfoKHR* forMarshaling);
+    const VkVideoDecodeH264CapabilitiesKHR* forMarshaling);
 
-void unmarshal_VkPipelineRenderingCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkPipelineRenderingCreateInfoKHR* forUnmarshaling);
+void unmarshal_VkVideoDecodeH264CapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkVideoDecodeH264CapabilitiesKHR* forUnmarshaling);
 
-void marshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+void marshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceDynamicRenderingFeaturesKHR* forMarshaling);
+    const VkVideoDecodeH264SessionParametersAddInfoKHR* forMarshaling);
 
-void unmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+void unmarshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceDynamicRenderingFeaturesKHR* forUnmarshaling);
+    VkVideoDecodeH264SessionParametersAddInfoKHR* forUnmarshaling);
 
-void marshal_VkCommandBufferInheritanceRenderingInfoKHR(
+void marshal_VkVideoDecodeH264SessionParametersCreateInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkCommandBufferInheritanceRenderingInfoKHR* forMarshaling);
+    const VkVideoDecodeH264SessionParametersCreateInfoKHR* forMarshaling);
 
-void unmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
+void unmarshal_VkVideoDecodeH264SessionParametersCreateInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkCommandBufferInheritanceRenderingInfoKHR* forUnmarshaling);
+    VkVideoDecodeH264SessionParametersCreateInfoKHR* forUnmarshaling);
+
+void marshal_VkVideoDecodeH264PictureInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoDecodeH264PictureInfoKHR* forMarshaling);
+
+void unmarshal_VkVideoDecodeH264PictureInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoDecodeH264PictureInfoKHR* forUnmarshaling);
+
+void marshal_VkVideoDecodeH264DpbSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoDecodeH264DpbSlotInfoKHR* forMarshaling);
+
+void unmarshal_VkVideoDecodeH264DpbSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoDecodeH264DpbSlotInfoKHR* forUnmarshaling);
+
+#endif
+#ifdef VK_KHR_dynamic_rendering
+DEFINE_ALIAS_FUNCTION(marshal_VkRenderingInfo, marshal_VkRenderingInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkRenderingInfo, unmarshal_VkRenderingInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(marshal_VkRenderingAttachmentInfo, marshal_VkRenderingAttachmentInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkRenderingAttachmentInfo, unmarshal_VkRenderingAttachmentInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(marshal_VkPipelineRenderingCreateInfo,
+                      marshal_VkPipelineRenderingCreateInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineRenderingCreateInfo,
+                      unmarshal_VkPipelineRenderingCreateInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceDynamicRenderingFeatures,
+                      marshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceDynamicRenderingFeatures,
+                      unmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR)
+
+DEFINE_ALIAS_FUNCTION(marshal_VkCommandBufferInheritanceRenderingInfo,
+                      marshal_VkCommandBufferInheritanceRenderingInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkCommandBufferInheritanceRenderingInfo,
+                      unmarshal_VkCommandBufferInheritanceRenderingInfoKHR)
 
 #define OP_vkCmdBeginRenderingKHR 298092805
 #define OP_vkCmdEndRenderingKHR 200651584
@@ -3015,6 +3477,75 @@ void unmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
     VkPhysicalDeviceShaderClockFeaturesKHR* forUnmarshaling);
 
 #endif
+#ifdef VK_KHR_video_decode_h265
+void marshal_VkVideoDecodeH265ProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoDecodeH265ProfileInfoKHR* forMarshaling);
+
+void unmarshal_VkVideoDecodeH265ProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoDecodeH265ProfileInfoKHR* forUnmarshaling);
+
+void marshal_VkVideoDecodeH265CapabilitiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoDecodeH265CapabilitiesKHR* forMarshaling);
+
+void unmarshal_VkVideoDecodeH265CapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkVideoDecodeH265CapabilitiesKHR* forUnmarshaling);
+
+void marshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoDecodeH265SessionParametersAddInfoKHR* forMarshaling);
+
+void unmarshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265SessionParametersAddInfoKHR* forUnmarshaling);
+
+void marshal_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoDecodeH265SessionParametersCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265SessionParametersCreateInfoKHR* forUnmarshaling);
+
+void marshal_VkVideoDecodeH265PictureInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoDecodeH265PictureInfoKHR* forMarshaling);
+
+void unmarshal_VkVideoDecodeH265PictureInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoDecodeH265PictureInfoKHR* forUnmarshaling);
+
+void marshal_VkVideoDecodeH265DpbSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoDecodeH265DpbSlotInfoKHR* forMarshaling);
+
+void unmarshal_VkVideoDecodeH265DpbSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoDecodeH265DpbSlotInfoKHR* forUnmarshaling);
+
+#endif
+#ifdef VK_KHR_global_priority
+void marshal_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDeviceQueueGlobalPriorityCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceQueueGlobalPriorityCreateInfoKHR* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* forUnmarshaling);
+
+void marshal_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkQueueFamilyGlobalPriorityPropertiesKHR* forMarshaling);
+
+void unmarshal_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkQueueFamilyGlobalPriorityPropertiesKHR* forUnmarshaling);
+
+#endif
 #ifdef VK_KHR_driver_properties
 DEFINE_ALIAS_FUNCTION(marshal_VkConformanceVersion, marshal_VkConformanceVersionKHR)
 
@@ -3095,13 +3626,11 @@ DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceVulkanMemoryModelFeatures,
 
 #endif
 #ifdef VK_KHR_shader_terminate_invocation
-void marshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderTerminateInvocationFeatures,
+                      marshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)
 
-void unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeatures,
+                      unmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)
 
 #endif
 #ifdef VK_KHR_fragment_shading_rate
@@ -3295,22 +3824,34 @@ void unmarshal_VkPipelineExecutableInternalRepresentationKHR(
 #define OP_vkGetPipelineExecutableStatisticsKHR 271191699
 #define OP_vkGetPipelineExecutableInternalRepresentationsKHR 274148497
 #endif
+#ifdef VK_KHR_map_memory2
+void marshal_VkMemoryMapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                const VkMemoryMapInfoKHR* forMarshaling);
+
+void unmarshal_VkMemoryMapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                  VkMemoryMapInfoKHR* forUnmarshaling);
+
+void marshal_VkMemoryUnmapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                  const VkMemoryUnmapInfoKHR* forMarshaling);
+
+void unmarshal_VkMemoryUnmapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                    VkMemoryUnmapInfoKHR* forUnmarshaling);
+
+#define OP_vkMapMemory2KHR 233122956
+#define OP_vkUnmapMemory2KHR 229780379
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
-void marshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderIntegerDotProductFeatures,
+                      marshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR)
 
-void unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeatures,
+                      unmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR)
 
-void marshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderIntegerDotProductProperties,
+                      marshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)
 
-void unmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderIntegerDotProductProperties,
+                      unmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)
 
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -3346,6 +3887,34 @@ void marshal_VkVideoEncodeInfoKHR(VulkanStream* vkStream, VkStructureType rootTy
 void unmarshal_VkVideoEncodeInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                     VkVideoEncodeInfoKHR* forUnmarshaling);
 
+void marshal_VkVideoEncodeCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                          const VkVideoEncodeCapabilitiesKHR* forMarshaling);
+
+void unmarshal_VkVideoEncodeCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                            VkVideoEncodeCapabilitiesKHR* forUnmarshaling);
+
+void marshal_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* forMarshaling);
+
+void unmarshal_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* forUnmarshaling);
+
+void marshal_VkVideoEncodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                       const VkVideoEncodeUsageInfoKHR* forMarshaling);
+
+void unmarshal_VkVideoEncodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkVideoEncodeUsageInfoKHR* forUnmarshaling);
+
+void marshal_VkVideoEncodeRateControlLayerInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoEncodeRateControlLayerInfoKHR* forMarshaling);
+
+void unmarshal_VkVideoEncodeRateControlLayerInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeRateControlLayerInfoKHR* forUnmarshaling);
+
 void marshal_VkVideoEncodeRateControlInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                              const VkVideoEncodeRateControlInfoKHR* forMarshaling);
 
@@ -3355,55 +3924,39 @@ void unmarshal_VkVideoEncodeRateControlInfoKHR(VulkanStream* vkStream, VkStructu
 #define OP_vkCmdEncodeVideoKHR 295869356
 #endif
 #ifdef VK_KHR_synchronization2
-void marshal_VkMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                 const VkMemoryBarrier2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkMemoryBarrier2, marshal_VkMemoryBarrier2KHR)
 
-void unmarshal_VkMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                   VkMemoryBarrier2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkMemoryBarrier2, unmarshal_VkMemoryBarrier2KHR)
 
-void marshal_VkBufferMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                       const VkBufferMemoryBarrier2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkBufferMemoryBarrier2, marshal_VkBufferMemoryBarrier2KHR)
 
-void unmarshal_VkBufferMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                         VkBufferMemoryBarrier2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkBufferMemoryBarrier2, unmarshal_VkBufferMemoryBarrier2KHR)
 
-void marshal_VkImageMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                      const VkImageMemoryBarrier2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkImageMemoryBarrier2, marshal_VkImageMemoryBarrier2KHR)
 
-void unmarshal_VkImageMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                        VkImageMemoryBarrier2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkImageMemoryBarrier2, unmarshal_VkImageMemoryBarrier2KHR)
 
-void marshal_VkDependencyInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                 const VkDependencyInfoKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkDependencyInfo, marshal_VkDependencyInfoKHR)
 
-void unmarshal_VkDependencyInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                   VkDependencyInfoKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDependencyInfo, unmarshal_VkDependencyInfoKHR)
 
-void marshal_VkSemaphoreSubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                      const VkSemaphoreSubmitInfoKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkSubmitInfo2, marshal_VkSubmitInfo2KHR)
 
-void unmarshal_VkSemaphoreSubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                        VkSemaphoreSubmitInfoKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkSubmitInfo2, unmarshal_VkSubmitInfo2KHR)
 
-void marshal_VkCommandBufferSubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                          const VkCommandBufferSubmitInfoKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkSemaphoreSubmitInfo, marshal_VkSemaphoreSubmitInfoKHR)
 
-void unmarshal_VkCommandBufferSubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                            VkCommandBufferSubmitInfoKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkSemaphoreSubmitInfo, unmarshal_VkSemaphoreSubmitInfoKHR)
 
-void marshal_VkSubmitInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                              const VkSubmitInfo2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkCommandBufferSubmitInfo, marshal_VkCommandBufferSubmitInfoKHR)
 
-void unmarshal_VkSubmitInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                VkSubmitInfo2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkCommandBufferSubmitInfo, unmarshal_VkCommandBufferSubmitInfoKHR)
 
-void marshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceSynchronization2FeaturesKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceSynchronization2Features,
+                      marshal_VkPhysicalDeviceSynchronization2FeaturesKHR)
 
-void unmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceSynchronization2FeaturesKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceSynchronization2Features,
+                      unmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR)
 
 #define OP_vkCmdSetEvent2KHR 270411360
 #define OP_vkCmdResetEvent2KHR 283215906
@@ -3428,6 +3981,24 @@ void unmarshal_VkCheckpointData2NV(VulkanStream* vkStream, VkStructureType rootT
 
 #define OP_vkGetQueueCheckpointData2NV 292063036
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+void marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* forUnmarshaling);
+
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 void marshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -3439,13 +4010,11 @@ void unmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
-void marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
+                      marshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR)
 
-void unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
+                      unmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR)
 
 #endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
@@ -3459,71 +4028,49 @@ void unmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_copy_commands2
-void marshal_VkBufferCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                              const VkBufferCopy2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkCopyBufferInfo2, marshal_VkCopyBufferInfo2KHR)
 
-void unmarshal_VkBufferCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                VkBufferCopy2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkCopyBufferInfo2, unmarshal_VkCopyBufferInfo2KHR)
 
-void marshal_VkCopyBufferInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                  const VkCopyBufferInfo2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkCopyImageInfo2, marshal_VkCopyImageInfo2KHR)
 
-void unmarshal_VkCopyBufferInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                    VkCopyBufferInfo2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkCopyImageInfo2, unmarshal_VkCopyImageInfo2KHR)
 
-void marshal_VkImageCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                             const VkImageCopy2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkCopyBufferToImageInfo2, marshal_VkCopyBufferToImageInfo2KHR)
 
-void unmarshal_VkImageCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                               VkImageCopy2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkCopyBufferToImageInfo2, unmarshal_VkCopyBufferToImageInfo2KHR)
 
-void marshal_VkCopyImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                 const VkCopyImageInfo2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkCopyImageToBufferInfo2, marshal_VkCopyImageToBufferInfo2KHR)
 
-void unmarshal_VkCopyImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                   VkCopyImageInfo2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkCopyImageToBufferInfo2, unmarshal_VkCopyImageToBufferInfo2KHR)
 
-void marshal_VkBufferImageCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                   const VkBufferImageCopy2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkBlitImageInfo2, marshal_VkBlitImageInfo2KHR)
 
-void unmarshal_VkBufferImageCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                     VkBufferImageCopy2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkBlitImageInfo2, unmarshal_VkBlitImageInfo2KHR)
 
-void marshal_VkCopyBufferToImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                         const VkCopyBufferToImageInfo2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkResolveImageInfo2, marshal_VkResolveImageInfo2KHR)
 
-void unmarshal_VkCopyBufferToImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkCopyBufferToImageInfo2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkResolveImageInfo2, unmarshal_VkResolveImageInfo2KHR)
 
-void marshal_VkCopyImageToBufferInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                         const VkCopyImageToBufferInfo2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkBufferCopy2, marshal_VkBufferCopy2KHR)
 
-void unmarshal_VkCopyImageToBufferInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkCopyImageToBufferInfo2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkBufferCopy2, unmarshal_VkBufferCopy2KHR)
 
-void marshal_VkImageBlit2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                             const VkImageBlit2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkImageCopy2, marshal_VkImageCopy2KHR)
 
-void unmarshal_VkImageBlit2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                               VkImageBlit2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkImageCopy2, unmarshal_VkImageCopy2KHR)
 
-void marshal_VkBlitImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                 const VkBlitImageInfo2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkImageBlit2, marshal_VkImageBlit2KHR)
 
-void unmarshal_VkBlitImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                   VkBlitImageInfo2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkImageBlit2, unmarshal_VkImageBlit2KHR)
 
-void marshal_VkImageResolve2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                const VkImageResolve2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkBufferImageCopy2, marshal_VkBufferImageCopy2KHR)
 
-void unmarshal_VkImageResolve2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                  VkImageResolve2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkBufferImageCopy2, unmarshal_VkBufferImageCopy2KHR)
 
-void marshal_VkResolveImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                    const VkResolveImageInfo2KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkImageResolve2, marshal_VkImageResolve2KHR)
 
-void unmarshal_VkResolveImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                      VkResolveImageInfo2KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkImageResolve2, unmarshal_VkImageResolve2KHR)
 
 #define OP_vkCmdCopyBuffer2KHR 247893766
 #define OP_vkCmdCopyImage2KHR 227008250
@@ -3533,60 +4080,102 @@ void unmarshal_VkResolveImageInfo2KHR(VulkanStream* vkStream, VkStructureType ro
 #define OP_vkCmdResolveImage2KHR 254857232
 #endif
 #ifdef VK_KHR_format_feature_flags2
-void marshal_VkFormatProperties3KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                    const VkFormatProperties3KHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkFormatProperties3, marshal_VkFormatProperties3KHR)
 
-void unmarshal_VkFormatProperties3KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                      VkFormatProperties3KHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkFormatProperties3, unmarshal_VkFormatProperties3KHR)
 
 #endif
-#ifdef VK_KHR_maintenance4
-void marshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
+#ifdef VK_KHR_ray_tracing_maintenance1
+void marshal_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceMaintenance4FeaturesKHR* forMarshaling);
+    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* forMarshaling);
 
-void unmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
+void unmarshal_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceMaintenance4FeaturesKHR* forUnmarshaling);
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* forUnmarshaling);
 
-void marshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceMaintenance4PropertiesKHR* forMarshaling);
+void marshal_VkTraceRaysIndirectCommand2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkTraceRaysIndirectCommand2KHR* forMarshaling);
 
-void unmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceMaintenance4PropertiesKHR* forUnmarshaling);
+void unmarshal_VkTraceRaysIndirectCommand2KHR(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkTraceRaysIndirectCommand2KHR* forUnmarshaling);
 
-void marshal_VkDeviceBufferMemoryRequirementsKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkDeviceBufferMemoryRequirementsKHR* forMarshaling);
+#define OP_vkCmdTraceRaysIndirect2KHR 261030897
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
+#ifdef VK_KHR_maintenance4
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceMaintenance4Features,
+                      marshal_VkPhysicalDeviceMaintenance4FeaturesKHR)
 
-void unmarshal_VkDeviceBufferMemoryRequirementsKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceBufferMemoryRequirementsKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceMaintenance4Features,
+                      unmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR)
 
-void marshal_VkDeviceImageMemoryRequirementsKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkDeviceImageMemoryRequirementsKHR* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceMaintenance4Properties,
+                      marshal_VkPhysicalDeviceMaintenance4PropertiesKHR)
 
-void unmarshal_VkDeviceImageMemoryRequirementsKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceImageMemoryRequirementsKHR* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceMaintenance4Properties,
+                      unmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR)
+
+DEFINE_ALIAS_FUNCTION(marshal_VkDeviceBufferMemoryRequirements,
+                      marshal_VkDeviceBufferMemoryRequirementsKHR)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceBufferMemoryRequirements,
+                      unmarshal_VkDeviceBufferMemoryRequirementsKHR)
+
+DEFINE_ALIAS_FUNCTION(marshal_VkDeviceImageMemoryRequirements,
+                      marshal_VkDeviceImageMemoryRequirementsKHR)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceImageMemoryRequirements,
+                      unmarshal_VkDeviceImageMemoryRequirementsKHR)
 
 #define OP_vkGetDeviceBufferMemoryRequirementsKHR 201613635
 #define OP_vkGetDeviceImageMemoryRequirementsKHR 243155021
 #define OP_vkGetDeviceImageSparseMemoryRequirementsKHR 275585477
 #endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+void marshal_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* forUnmarshaling);
+
+#endif
 #ifdef VK_ANDROID_native_buffer
+void marshal_VkNativeBufferUsage2ANDROID(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkNativeBufferUsage2ANDROID* forMarshaling);
+
+void unmarshal_VkNativeBufferUsage2ANDROID(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkNativeBufferUsage2ANDROID* forUnmarshaling);
+
 void marshal_VkNativeBufferANDROID(VulkanStream* vkStream, VkStructureType rootType,
                                    const VkNativeBufferANDROID* forMarshaling);
 
 void unmarshal_VkNativeBufferANDROID(VulkanStream* vkStream, VkStructureType rootType,
                                      VkNativeBufferANDROID* forUnmarshaling);
 
+void marshal_VkSwapchainImageCreateInfoANDROID(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSwapchainImageCreateInfoANDROID* forMarshaling);
+
+void unmarshal_VkSwapchainImageCreateInfoANDROID(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainImageCreateInfoANDROID* forUnmarshaling);
+
+void marshal_VkPhysicalDevicePresentationPropertiesANDROID(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePresentationPropertiesANDROID* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePresentationPropertiesANDROID(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePresentationPropertiesANDROID* forUnmarshaling);
+
 #define OP_vkGetSwapchainGrallocUsageANDROID 20251
 #define OP_vkAcquireImageANDROID 20252
 #define OP_vkQueueSignalReleaseImageANDROID 20253
+#define OP_vkGetSwapchainGrallocUsage2ANDROID 287960452
 #endif
 #ifdef VK_EXT_debug_report
 void marshal_VkDebugReportCallbackCreateInfoEXT(
@@ -3765,14 +4354,6 @@ void marshal_VkVideoEncodeH264CapabilitiesEXT(
 void unmarshal_VkVideoEncodeH264CapabilitiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                 VkVideoEncodeH264CapabilitiesEXT* forUnmarshaling);
 
-void marshal_VkVideoEncodeH264SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoEncodeH264SessionCreateInfoEXT* forMarshaling);
-
-void unmarshal_VkVideoEncodeH264SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH264SessionCreateInfoEXT* forUnmarshaling);
-
 void marshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     const VkVideoEncodeH264SessionParametersAddInfoEXT* forMarshaling);
@@ -3789,17 +4370,13 @@ void unmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkVideoEncodeH264SessionParametersCreateInfoEXT* forUnmarshaling);
 
-void marshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling);
-
-void unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoEncodeH264DpbSlotInfoEXT* forUnmarshaling);
-
-void marshal_VkVideoEncodeH264NaluSliceEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           const VkVideoEncodeH264NaluSliceEXT* forMarshaling);
+void marshal_VkVideoEncodeH264NaluSliceInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoEncodeH264NaluSliceInfoEXT* forMarshaling);
 
-void unmarshal_VkVideoEncodeH264NaluSliceEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             VkVideoEncodeH264NaluSliceEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH264NaluSliceInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH264NaluSliceInfoEXT* forUnmarshaling);
 
 void marshal_VkVideoEncodeH264VclFrameInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -3808,19 +4385,45 @@ void marshal_VkVideoEncodeH264VclFrameInfoEXT(
 void unmarshal_VkVideoEncodeH264VclFrameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                 VkVideoEncodeH264VclFrameInfoEXT* forUnmarshaling);
 
-void marshal_VkVideoEncodeH264EmitPictureParametersEXT(
+void marshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoEncodeH264DpbSlotInfoEXT* forMarshaling);
+
+void unmarshal_VkVideoEncodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoEncodeH264DpbSlotInfoEXT* forUnmarshaling);
+
+void marshal_VkVideoEncodeH264ProfileInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoEncodeH264ProfileInfoEXT* forMarshaling);
+
+void unmarshal_VkVideoEncodeH264ProfileInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoEncodeH264ProfileInfoEXT* forUnmarshaling);
+
+void marshal_VkVideoEncodeH264RateControlInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoEncodeH264EmitPictureParametersEXT* forMarshaling);
+    const VkVideoEncodeH264RateControlInfoEXT* forMarshaling);
 
-void unmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
+void unmarshal_VkVideoEncodeH264RateControlInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH264EmitPictureParametersEXT* forUnmarshaling);
+    VkVideoEncodeH264RateControlInfoEXT* forUnmarshaling);
+
+void marshal_VkVideoEncodeH264QpEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkVideoEncodeH264QpEXT* forMarshaling);
+
+void unmarshal_VkVideoEncodeH264QpEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkVideoEncodeH264QpEXT* forUnmarshaling);
 
-void marshal_VkVideoEncodeH264ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                         const VkVideoEncodeH264ProfileEXT* forMarshaling);
+void marshal_VkVideoEncodeH264FrameSizeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkVideoEncodeH264FrameSizeEXT* forMarshaling);
 
-void unmarshal_VkVideoEncodeH264ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkVideoEncodeH264ProfileEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH264FrameSizeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkVideoEncodeH264FrameSizeEXT* forUnmarshaling);
+
+void marshal_VkVideoEncodeH264RateControlLayerInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkVideoEncodeH264RateControlLayerInfoEXT* forMarshaling);
+
+void unmarshal_VkVideoEncodeH264RateControlLayerInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH264RateControlLayerInfoEXT* forUnmarshaling);
 
 #endif
 #ifdef VK_EXT_video_encode_h265
@@ -3831,14 +4434,6 @@ void marshal_VkVideoEncodeH265CapabilitiesEXT(
 void unmarshal_VkVideoEncodeH265CapabilitiesEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                 VkVideoEncodeH265CapabilitiesEXT* forUnmarshaling);
 
-void marshal_VkVideoEncodeH265SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoEncodeH265SessionCreateInfoEXT* forMarshaling);
-
-void unmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265SessionCreateInfoEXT* forUnmarshaling);
-
 void marshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     const VkVideoEncodeH265SessionParametersAddInfoEXT* forMarshaling);
@@ -3855,25 +4450,13 @@ void unmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkVideoEncodeH265SessionParametersCreateInfoEXT* forUnmarshaling);
 
-void marshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling);
-
-void unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoEncodeH265DpbSlotInfoEXT* forUnmarshaling);
-
-void marshal_VkVideoEncodeH265ReferenceListsEXT(
+void marshal_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoEncodeH265ReferenceListsEXT* forMarshaling);
+    const VkVideoEncodeH265NaluSliceSegmentInfoEXT* forMarshaling);
 
-void unmarshal_VkVideoEncodeH265ReferenceListsEXT(
+void unmarshal_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265ReferenceListsEXT* forUnmarshaling);
-
-void marshal_VkVideoEncodeH265NaluSliceEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           const VkVideoEncodeH265NaluSliceEXT* forMarshaling);
-
-void unmarshal_VkVideoEncodeH265NaluSliceEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             VkVideoEncodeH265NaluSliceEXT* forUnmarshaling);
+    VkVideoEncodeH265NaluSliceSegmentInfoEXT* forUnmarshaling);
 
 void marshal_VkVideoEncodeH265VclFrameInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -3882,76 +4465,45 @@ void marshal_VkVideoEncodeH265VclFrameInfoEXT(
 void unmarshal_VkVideoEncodeH265VclFrameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
                                                 VkVideoEncodeH265VclFrameInfoEXT* forUnmarshaling);
 
-void marshal_VkVideoEncodeH265EmitPictureParametersEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoEncodeH265EmitPictureParametersEXT* forMarshaling);
-
-void unmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265EmitPictureParametersEXT* forUnmarshaling);
-
-void marshal_VkVideoEncodeH265ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                         const VkVideoEncodeH265ProfileEXT* forMarshaling);
+void marshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoEncodeH265DpbSlotInfoEXT* forMarshaling);
 
-void unmarshal_VkVideoEncodeH265ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkVideoEncodeH265ProfileEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoEncodeH265DpbSlotInfoEXT* forUnmarshaling);
 
-#endif
-#ifdef VK_EXT_video_decode_h264
-void marshal_VkVideoDecodeH264ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                         const VkVideoDecodeH264ProfileEXT* forMarshaling);
+void marshal_VkVideoEncodeH265ProfileInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkVideoEncodeH265ProfileInfoEXT* forMarshaling);
 
-void unmarshal_VkVideoDecodeH264ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkVideoDecodeH264ProfileEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH265ProfileInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkVideoEncodeH265ProfileInfoEXT* forUnmarshaling);
 
-void marshal_VkVideoDecodeH264CapabilitiesEXT(
+void marshal_VkVideoEncodeH265RateControlInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH264CapabilitiesEXT* forMarshaling);
+    const VkVideoEncodeH265RateControlInfoEXT* forMarshaling);
 
-void unmarshal_VkVideoDecodeH264CapabilitiesEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkVideoDecodeH264CapabilitiesEXT* forUnmarshaling);
-
-void marshal_VkVideoDecodeH264SessionCreateInfoEXT(
+void unmarshal_VkVideoEncodeH265RateControlInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH264SessionCreateInfoEXT* forMarshaling);
+    VkVideoEncodeH265RateControlInfoEXT* forUnmarshaling);
 
-void unmarshal_VkVideoDecodeH264SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264SessionCreateInfoEXT* forUnmarshaling);
+void marshal_VkVideoEncodeH265QpEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkVideoEncodeH265QpEXT* forMarshaling);
 
-void marshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH264SessionParametersAddInfoEXT* forMarshaling);
+void unmarshal_VkVideoEncodeH265QpEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkVideoEncodeH265QpEXT* forUnmarshaling);
 
-void unmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264SessionParametersAddInfoEXT* forUnmarshaling);
+void marshal_VkVideoEncodeH265FrameSizeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkVideoEncodeH265FrameSizeEXT* forMarshaling);
 
-void marshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH264SessionParametersCreateInfoEXT* forMarshaling);
+void unmarshal_VkVideoEncodeH265FrameSizeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkVideoEncodeH265FrameSizeEXT* forUnmarshaling);
 
-void unmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+void marshal_VkVideoEncodeH265RateControlLayerInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264SessionParametersCreateInfoEXT* forUnmarshaling);
-
-void marshal_VkVideoDecodeH264PictureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             const VkVideoDecodeH264PictureInfoEXT* forMarshaling);
+    const VkVideoEncodeH265RateControlLayerInfoEXT* forMarshaling);
 
-void unmarshal_VkVideoDecodeH264PictureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoDecodeH264PictureInfoEXT* forUnmarshaling);
-
-void marshal_VkVideoDecodeH264MvcEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                     const VkVideoDecodeH264MvcEXT* forMarshaling);
-
-void unmarshal_VkVideoDecodeH264MvcEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                       VkVideoDecodeH264MvcEXT* forUnmarshaling);
-
-void marshal_VkVideoDecodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             const VkVideoDecodeH264DpbSlotInfoEXT* forMarshaling);
-
-void unmarshal_VkVideoDecodeH264DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoDecodeH264DpbSlotInfoEXT* forUnmarshaling);
+void unmarshal_VkVideoEncodeH265RateControlLayerInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH265RateControlLayerInfoEXT* forUnmarshaling);
 
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
@@ -4078,13 +4630,11 @@ void unmarshal_VkViSurfaceCreateInfoNN(VulkanStream* vkStream, VkStructureType r
 #ifdef VK_EXT_shader_subgroup_vote
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
-void marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures,
+                      marshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
 
-void unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures,
+                      unmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
 
 #endif
 #ifdef VK_EXT_astc_decode_mode
@@ -4103,6 +4653,32 @@ void unmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
     VkPhysicalDeviceASTCDecodeFeaturesEXT* forUnmarshaling);
 
 #endif
+#ifdef VK_EXT_pipeline_robustness
+void marshal_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT* forUnmarshaling);
+
+void marshal_VkPipelineRobustnessCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelineRobustnessCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineRobustnessCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineRobustnessCreateInfoEXT* forUnmarshaling);
+
+#endif
 #ifdef VK_EXT_conditional_rendering
 void marshal_VkConditionalRenderingBeginInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -4272,6 +4848,8 @@ void unmarshal_VkPipelineDiscardRectangleStateCreateInfoEXT(
     VkPipelineDiscardRectangleStateCreateInfoEXT* forUnmarshaling);
 
 #define OP_vkCmdSetDiscardRectangleEXT 20290
+#define OP_vkCmdSetDiscardRectangleEnableEXT 283949626
+#define OP_vkCmdSetDiscardRectangleModeEXT 223142341
 #endif
 #ifdef VK_EXT_conservative_rasterization
 void marshal_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(
@@ -4344,14 +4922,6 @@ void unmarshal_VkMacOSSurfaceCreateInfoMVK(VulkanStream* vkStream, VkStructureTy
 
 #define OP_vkCreateMacOSSurfaceMVK 20293
 #endif
-#ifdef VK_MVK_moltenvk
-#define OP_vkGetMTLDeviceMVK 20334
-#define OP_vkSetMTLTextureMVK 20335
-#define OP_vkGetMTLTextureMVK 20336
-#define OP_vkGetMTLBufferMVK 20337
-#define OP_vkUseIOSurfaceMVK 20338
-#define OP_vkGetIOSurfaceMVK 20339
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -4482,37 +5052,29 @@ DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceSamplerFilterMinmaxProperties,
 #ifdef VK_AMD_shader_fragment_mask
 #endif
 #ifdef VK_EXT_inline_uniform_block
-void marshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceInlineUniformBlockFeatures,
+                      marshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT)
 
-void unmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceInlineUniformBlockFeatures,
+                      unmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT)
 
-void marshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceInlineUniformBlockProperties,
+                      marshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT)
 
-void unmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceInlineUniformBlockProperties,
+                      unmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT)
 
-void marshal_VkWriteDescriptorSetInlineUniformBlockEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkWriteDescriptorSetInlineUniformBlockEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkWriteDescriptorSetInlineUniformBlock,
+                      marshal_VkWriteDescriptorSetInlineUniformBlockEXT)
 
-void unmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkWriteDescriptorSetInlineUniformBlockEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkWriteDescriptorSetInlineUniformBlock,
+                      unmarshal_VkWriteDescriptorSetInlineUniformBlockEXT)
 
-void marshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkDescriptorPoolInlineUniformBlockCreateInfo,
+                      marshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)
 
-void unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfo,
+                      unmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_shader_stencil_export
@@ -4991,13 +5553,11 @@ void unmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
 #ifdef VK_QCOM_render_pass_shader_resolve
 #endif
 #ifdef VK_EXT_global_priority
-void marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkDeviceQueueGlobalPriorityCreateInfoEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkDeviceQueueGlobalPriorityCreateInfoKHR,
+                      marshal_VkDeviceQueueGlobalPriorityCreateInfoEXT)
 
-void unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDeviceQueueGlobalPriorityCreateInfoKHR,
+                      unmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_external_memory_host
@@ -5058,57 +5618,6 @@ void unmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
     VkPhysicalDeviceShaderCorePropertiesAMD* forUnmarshaling);
 
 #endif
-#ifdef VK_EXT_video_decode_h265
-void marshal_VkVideoDecodeH265ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                         const VkVideoDecodeH265ProfileEXT* forMarshaling);
-
-void unmarshal_VkVideoDecodeH265ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkVideoDecodeH265ProfileEXT* forUnmarshaling);
-
-void marshal_VkVideoDecodeH265CapabilitiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH265CapabilitiesEXT* forMarshaling);
-
-void unmarshal_VkVideoDecodeH265CapabilitiesEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkVideoDecodeH265CapabilitiesEXT* forUnmarshaling);
-
-void marshal_VkVideoDecodeH265SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH265SessionCreateInfoEXT* forMarshaling);
-
-void unmarshal_VkVideoDecodeH265SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265SessionCreateInfoEXT* forUnmarshaling);
-
-void marshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH265SessionParametersAddInfoEXT* forMarshaling);
-
-void unmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265SessionParametersAddInfoEXT* forUnmarshaling);
-
-void marshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkVideoDecodeH265SessionParametersCreateInfoEXT* forMarshaling);
-
-void unmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265SessionParametersCreateInfoEXT* forUnmarshaling);
-
-void marshal_VkVideoDecodeH265PictureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             const VkVideoDecodeH265PictureInfoEXT* forMarshaling);
-
-void unmarshal_VkVideoDecodeH265PictureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoDecodeH265PictureInfoEXT* forUnmarshaling);
-
-void marshal_VkVideoDecodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             const VkVideoDecodeH265DpbSlotInfoEXT* forMarshaling);
-
-void unmarshal_VkVideoDecodeH265DpbSlotInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoDecodeH265DpbSlotInfoEXT* forUnmarshaling);
-
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 void marshal_VkDeviceMemoryOverallocationCreateInfoAMD(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -5162,19 +5671,15 @@ void unmarshal_VkPresentFrameTokenGGP(VulkanStream* vkStream, VkStructureType ro
 
 #endif
 #ifdef VK_EXT_pipeline_creation_feedback
-void marshal_VkPipelineCreationFeedbackEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                           const VkPipelineCreationFeedbackEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPipelineCreationFeedbackCreateInfo,
+                      marshal_VkPipelineCreationFeedbackCreateInfoEXT)
 
-void unmarshal_VkPipelineCreationFeedbackEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                             VkPipelineCreationFeedbackEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineCreationFeedbackCreateInfo,
+                      unmarshal_VkPipelineCreationFeedbackCreateInfoEXT)
 
-void marshal_VkPipelineCreationFeedbackCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPipelineCreationFeedbackCreateInfoEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPipelineCreationFeedback, marshal_VkPipelineCreationFeedbackEXT)
 
-void unmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPipelineCreationFeedbackCreateInfoEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineCreationFeedback, unmarshal_VkPipelineCreationFeedbackEXT)
 
 #endif
 #ifdef VK_NV_shader_subgroup_partitioned
@@ -5218,13 +5723,11 @@ void unmarshal_VkDrawMeshTasksIndirectCommandNV(VulkanStream* vkStream, VkStruct
 #define OP_vkCmdDrawMeshTasksIndirectCountNV 223801967
 #endif
 #ifdef VK_NV_fragment_shader_barycentric
-void marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
+                      marshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV)
 
-void unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
+                      unmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV)
 
 #endif
 #ifdef VK_NV_shader_image_footprint
@@ -5254,6 +5757,7 @@ void unmarshal_VkPhysicalDeviceExclusiveScissorFeaturesNV(
     VulkanStream* vkStream, VkStructureType rootType,
     VkPhysicalDeviceExclusiveScissorFeaturesNV* forUnmarshaling);
 
+#define OP_vkCmdSetExclusiveScissorEnableNV 291183995
 #define OP_vkCmdSetExclusiveScissorNV 225408194
 #endif
 #ifdef VK_NV_device_diagnostic_checkpoints
@@ -5445,29 +5949,23 @@ DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceScalarBlockLayoutFeatures,
 #ifdef VK_GOOGLE_decorate_string
 #endif
 #ifdef VK_EXT_subgroup_size_control
-void marshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceSubgroupSizeControlFeatures,
+                      marshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)
 
-void unmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceSubgroupSizeControlFeatures,
+                      unmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)
 
-void marshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceSubgroupSizeControlProperties,
+                      marshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT)
 
-void unmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceSubgroupSizeControlProperties,
+                      unmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT)
 
-void marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)
 
-void unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)
 
 #endif
 #ifdef VK_AMD_shader_core_properties2
@@ -5566,13 +6064,11 @@ void unmarshal_VkBufferDeviceAddressCreateInfoEXT(
 #define OP_vkGetBufferDeviceAddressEXT 224361693
 #endif
 #ifdef VK_EXT_tooling_info
-void marshal_VkPhysicalDeviceToolPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceToolPropertiesEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceToolProperties,
+                      marshal_VkPhysicalDeviceToolPropertiesEXT)
 
-void unmarshal_VkPhysicalDeviceToolPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceToolPropertiesEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceToolProperties,
+                      unmarshal_VkPhysicalDeviceToolPropertiesEXT)
 
 #define OP_vkGetPhysicalDeviceToolPropertiesEXT 282247593
 #endif
@@ -5817,14 +6313,81 @@ void unmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
     VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forUnmarshaling);
 
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-void marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+void marshal_VkSurfacePresentModeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     const VkSurfacePresentModeEXT* forMarshaling);
+
+void unmarshal_VkSurfacePresentModeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkSurfacePresentModeEXT* forUnmarshaling);
+
+void marshal_VkSurfacePresentScalingCapabilitiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSurfacePresentScalingCapabilitiesEXT* forMarshaling);
+
+void unmarshal_VkSurfacePresentScalingCapabilitiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSurfacePresentScalingCapabilitiesEXT* forUnmarshaling);
+
+void marshal_VkSurfacePresentModeCompatibilityEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forMarshaling);
+    const VkSurfacePresentModeCompatibilityEXT* forMarshaling);
 
-void unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+void unmarshal_VkSurfacePresentModeCompatibilityEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forUnmarshaling);
+    VkSurfacePresentModeCompatibilityEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+void marshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* forUnmarshaling);
+
+void marshal_VkSwapchainPresentFenceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkSwapchainPresentFenceInfoEXT* forMarshaling);
+
+void unmarshal_VkSwapchainPresentFenceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkSwapchainPresentFenceInfoEXT* forUnmarshaling);
+
+void marshal_VkSwapchainPresentModesCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSwapchainPresentModesCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkSwapchainPresentModesCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainPresentModesCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkSwapchainPresentModeInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkSwapchainPresentModeInfoEXT* forMarshaling);
+
+void unmarshal_VkSwapchainPresentModeInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkSwapchainPresentModeInfoEXT* forUnmarshaling);
+
+void marshal_VkSwapchainPresentScalingCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSwapchainPresentScalingCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkSwapchainPresentScalingCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainPresentScalingCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkReleaseSwapchainImagesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkReleaseSwapchainImagesInfoEXT* forMarshaling);
+
+void unmarshal_VkReleaseSwapchainImagesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkReleaseSwapchainImagesInfoEXT* forUnmarshaling);
+
+#define OP_vkReleaseSwapchainImagesEXT 230545069
+#endif
+#ifdef VK_EXT_shader_demote_to_helper_invocation
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures,
+                      marshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures,
+                      unmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)
 
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -5959,13 +6522,11 @@ void unmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forUnmarshaling);
 
-void marshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceTexelBufferAlignmentProperties,
+                      marshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)
 
-void unmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceTexelBufferAlignmentProperties,
+                      unmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)
 
 #endif
 #ifdef VK_QCOM_render_pass_transform
@@ -6062,27 +6623,49 @@ void unmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
-#ifdef VK_EXT_private_data
-void marshal_VkPhysicalDevicePrivateDataFeaturesEXT(
+#ifdef VK_NV_present_barrier
+void marshal_VkPhysicalDevicePresentBarrierFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePresentBarrierFeaturesNV* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePresentBarrierFeaturesNV(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDevicePrivateDataFeaturesEXT* forMarshaling);
+    VkPhysicalDevicePresentBarrierFeaturesNV* forUnmarshaling);
 
-void unmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
+void marshal_VkSurfaceCapabilitiesPresentBarrierNV(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDevicePrivateDataFeaturesEXT* forUnmarshaling);
+    const VkSurfaceCapabilitiesPresentBarrierNV* forMarshaling);
 
-void marshal_VkDevicePrivateDataCreateInfoEXT(
+void unmarshal_VkSurfaceCapabilitiesPresentBarrierNV(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkDevicePrivateDataCreateInfoEXT* forMarshaling);
+    VkSurfaceCapabilitiesPresentBarrierNV* forUnmarshaling);
 
-void unmarshal_VkDevicePrivateDataCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkDevicePrivateDataCreateInfoEXT* forUnmarshaling);
+void marshal_VkSwapchainPresentBarrierCreateInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSwapchainPresentBarrierCreateInfoNV* forMarshaling);
+
+void unmarshal_VkSwapchainPresentBarrierCreateInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainPresentBarrierCreateInfoNV* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_private_data
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDevicePrivateDataFeatures,
+                      marshal_VkPhysicalDevicePrivateDataFeaturesEXT)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDevicePrivateDataFeatures,
+                      unmarshal_VkPhysicalDevicePrivateDataFeaturesEXT)
+
+DEFINE_ALIAS_FUNCTION(marshal_VkDevicePrivateDataCreateInfo,
+                      marshal_VkDevicePrivateDataCreateInfoEXT)
 
-void marshal_VkPrivateDataSlotCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                            const VkPrivateDataSlotCreateInfoEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkDevicePrivateDataCreateInfo,
+                      unmarshal_VkDevicePrivateDataCreateInfoEXT)
 
-void unmarshal_VkPrivateDataSlotCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                              VkPrivateDataSlotCreateInfoEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPrivateDataSlotCreateInfo, marshal_VkPrivateDataSlotCreateInfoEXT)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPrivateDataSlotCreateInfo,
+                      unmarshal_VkPrivateDataSlotCreateInfoEXT)
 
 #define OP_vkCreatePrivateDataSlotEXT 236374049
 #define OP_vkDestroyPrivateDataSlotEXT 208891309
@@ -6090,13 +6673,11 @@ void unmarshal_VkPrivateDataSlotCreateInfoEXT(VulkanStream* vkStream, VkStructur
 #define OP_vkGetPrivateDataEXT 291399427
 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
-void marshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDevicePipelineCreationCacheControlFeatures,
+                      marshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT)
 
-void unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeatures,
+                      unmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT)
 
 #endif
 #ifdef VK_NV_device_diagnostics_config
@@ -6119,6 +6700,245 @@ void unmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+void marshal_VkQueryLowLatencySupportNV(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkQueryLowLatencySupportNV* forMarshaling);
+
+void unmarshal_VkQueryLowLatencySupportNV(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkQueryLowLatencySupportNV* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_metal_objects
+void marshal_VkExportMetalObjectCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkExportMetalObjectCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkExportMetalObjectCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkExportMetalObjectCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkExportMetalObjectsInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkExportMetalObjectsInfoEXT* forMarshaling);
+
+void unmarshal_VkExportMetalObjectsInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkExportMetalObjectsInfoEXT* forUnmarshaling);
+
+void marshal_VkExportMetalDeviceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkExportMetalDeviceInfoEXT* forMarshaling);
+
+void unmarshal_VkExportMetalDeviceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkExportMetalDeviceInfoEXT* forUnmarshaling);
+
+void marshal_VkExportMetalCommandQueueInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkExportMetalCommandQueueInfoEXT* forMarshaling);
+
+void unmarshal_VkExportMetalCommandQueueInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkExportMetalCommandQueueInfoEXT* forUnmarshaling);
+
+void marshal_VkExportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkExportMetalBufferInfoEXT* forMarshaling);
+
+void unmarshal_VkExportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkExportMetalBufferInfoEXT* forUnmarshaling);
+
+void marshal_VkImportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkImportMetalBufferInfoEXT* forMarshaling);
+
+void unmarshal_VkImportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkImportMetalBufferInfoEXT* forUnmarshaling);
+
+void marshal_VkExportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkExportMetalTextureInfoEXT* forMarshaling);
+
+void unmarshal_VkExportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkExportMetalTextureInfoEXT* forUnmarshaling);
+
+void marshal_VkImportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkImportMetalTextureInfoEXT* forMarshaling);
+
+void unmarshal_VkImportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkImportMetalTextureInfoEXT* forUnmarshaling);
+
+void marshal_VkExportMetalIOSurfaceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkExportMetalIOSurfaceInfoEXT* forMarshaling);
+
+void unmarshal_VkExportMetalIOSurfaceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkExportMetalIOSurfaceInfoEXT* forUnmarshaling);
+
+void marshal_VkImportMetalIOSurfaceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkImportMetalIOSurfaceInfoEXT* forMarshaling);
+
+void unmarshal_VkImportMetalIOSurfaceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkImportMetalIOSurfaceInfoEXT* forUnmarshaling);
+
+void marshal_VkExportMetalSharedEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkExportMetalSharedEventInfoEXT* forMarshaling);
+
+void unmarshal_VkExportMetalSharedEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkExportMetalSharedEventInfoEXT* forUnmarshaling);
+
+void marshal_VkImportMetalSharedEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkImportMetalSharedEventInfoEXT* forMarshaling);
+
+void unmarshal_VkImportMetalSharedEventInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkImportMetalSharedEventInfoEXT* forUnmarshaling);
+
+#define OP_vkExportMetalObjectsEXT 277713148
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void marshal_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorBufferPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorBufferFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT* forUnmarshaling);
+
+void marshal_VkDescriptorAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkDescriptorAddressInfoEXT* forMarshaling);
+
+void unmarshal_VkDescriptorAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkDescriptorAddressInfoEXT* forUnmarshaling);
+
+void marshal_VkDescriptorBufferBindingInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDescriptorBufferBindingInfoEXT* forMarshaling);
+
+void unmarshal_VkDescriptorBufferBindingInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkDescriptorBufferBindingInfoEXT* forUnmarshaling);
+
+void marshal_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* forMarshaling);
+
+void unmarshal_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* forUnmarshaling);
+
+void marshal_VkDescriptorDataEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                 const VkDescriptorDataEXT* forMarshaling);
+
+void unmarshal_VkDescriptorDataEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                   VkDescriptorDataEXT* forUnmarshaling);
+
+void marshal_VkDescriptorGetInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkDescriptorGetInfoEXT* forMarshaling);
+
+void unmarshal_VkDescriptorGetInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkDescriptorGetInfoEXT* forUnmarshaling);
+
+void marshal_VkBufferCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkBufferCaptureDescriptorDataInfoEXT* forMarshaling);
+
+void unmarshal_VkBufferCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkBufferCaptureDescriptorDataInfoEXT* forUnmarshaling);
+
+void marshal_VkImageCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkImageCaptureDescriptorDataInfoEXT* forMarshaling);
+
+void unmarshal_VkImageCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageCaptureDescriptorDataInfoEXT* forUnmarshaling);
+
+void marshal_VkImageViewCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkImageViewCaptureDescriptorDataInfoEXT* forMarshaling);
+
+void unmarshal_VkImageViewCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageViewCaptureDescriptorDataInfoEXT* forUnmarshaling);
+
+void marshal_VkSamplerCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSamplerCaptureDescriptorDataInfoEXT* forMarshaling);
+
+void unmarshal_VkSamplerCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSamplerCaptureDescriptorDataInfoEXT* forUnmarshaling);
+
+void marshal_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkOpaqueCaptureDescriptorDataCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpaqueCaptureDescriptorDataCreateInfoEXT* forUnmarshaling);
+
+#define OP_vkGetDescriptorSetLayoutSizeEXT 232397397
+#define OP_vkGetDescriptorSetLayoutBindingOffsetEXT 221321639
+#define OP_vkGetDescriptorEXT 202393542
+#define OP_vkCmdBindDescriptorBuffersEXT 269092586
+#define OP_vkCmdSetDescriptorBufferOffsetsEXT 271032334
+#define OP_vkCmdBindDescriptorBufferEmbeddedSamplersEXT 203513976
+#define OP_vkGetBufferOpaqueCaptureDescriptorDataEXT 280732261
+#define OP_vkGetImageOpaqueCaptureDescriptorDataEXT 244010315
+#define OP_vkGetImageViewOpaqueCaptureDescriptorDataEXT 225288362
+#define OP_vkGetSamplerOpaqueCaptureDescriptorDataEXT 273812428
+void marshal_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* forMarshaling);
+
+void unmarshal_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT* forUnmarshaling);
+
+#define OP_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT 289643264
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+void marshal_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* forUnmarshaling);
+
+void marshal_VkGraphicsPipelineLibraryCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkGraphicsPipelineLibraryCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkGraphicsPipelineLibraryCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkGraphicsPipelineLibraryCreateInfoEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+void marshal_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* forUnmarshaling);
+
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void marshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -6253,13 +7073,56 @@ void unmarshal_VkCopyCommandTransformInfoQCOM(VulkanStream* vkStream, VkStructur
 
 #endif
 #ifdef VK_EXT_image_robustness
-void marshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceImageRobustnessFeatures,
+                      marshal_VkPhysicalDeviceImageRobustnessFeaturesEXT)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceImageRobustnessFeatures,
+                      unmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT)
+
+#endif
+#ifdef VK_EXT_image_compression_control
+void marshal_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT* forUnmarshaling);
+
+void marshal_VkImageCompressionControlEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          const VkImageCompressionControlEXT* forMarshaling);
+
+void unmarshal_VkImageCompressionControlEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            VkImageCompressionControlEXT* forUnmarshaling);
+
+void marshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     const VkSubresourceLayout2EXT* forMarshaling);
+
+void unmarshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkSubresourceLayout2EXT* forUnmarshaling);
+
+void marshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkImageSubresource2EXT* forMarshaling);
+
+void unmarshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkImageSubresource2EXT* forUnmarshaling);
+
+void marshal_VkImageCompressionPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkImageCompressionPropertiesEXT* forMarshaling);
+
+void unmarshal_VkImageCompressionPropertiesEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkImageCompressionPropertiesEXT* forUnmarshaling);
+
+#define OP_vkGetImageSubresourceLayout2EXT 296152177
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+void marshal_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceImageRobustnessFeaturesEXT* forMarshaling);
+    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* forMarshaling);
 
-void unmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+void unmarshal_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceImageRobustnessFeaturesEXT* forUnmarshaling);
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* forUnmarshaling);
 
 #endif
 #ifdef VK_EXT_4444_formats
@@ -6272,6 +7135,64 @@ void unmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
     VkPhysicalDevice4444FormatsFeaturesEXT* forUnmarshaling);
 
 #endif
+#ifdef VK_EXT_device_fault
+void marshal_VkPhysicalDeviceFaultFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceFaultFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceFaultFeaturesEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkPhysicalDeviceFaultFeaturesEXT* forUnmarshaling);
+
+void marshal_VkDeviceFaultCountsEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkDeviceFaultCountsEXT* forMarshaling);
+
+void unmarshal_VkDeviceFaultCountsEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkDeviceFaultCountsEXT* forUnmarshaling);
+
+void marshal_VkDeviceFaultAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkDeviceFaultAddressInfoEXT* forMarshaling);
+
+void unmarshal_VkDeviceFaultAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkDeviceFaultAddressInfoEXT* forUnmarshaling);
+
+void marshal_VkDeviceFaultVendorInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkDeviceFaultVendorInfoEXT* forMarshaling);
+
+void unmarshal_VkDeviceFaultVendorInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkDeviceFaultVendorInfoEXT* forUnmarshaling);
+
+void marshal_VkDeviceFaultInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                  const VkDeviceFaultInfoEXT* forMarshaling);
+
+void unmarshal_VkDeviceFaultInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    VkDeviceFaultInfoEXT* forUnmarshaling);
+
+void marshal_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDeviceFaultVendorBinaryHeaderVersionOneEXT* forMarshaling);
+
+void unmarshal_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceFaultVendorBinaryHeaderVersionOneEXT* forUnmarshaling);
+
+#define OP_vkGetDeviceFaultInfoEXT 278838285
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+void marshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* forUnmarshaling);
+
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
+                      marshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
+                      unmarshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM)
+
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 void marshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -6297,28 +7218,45 @@ void unmarshal_VkDirectFBSurfaceCreateInfoEXT(VulkanStream* vkStream, VkStructur
 #define OP_vkGetPhysicalDeviceDirectFBPresentationSupportEXT 285441990
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-void marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+void marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forMarshaling);
+    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* forMarshaling);
 
-void unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+void unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forUnmarshaling);
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* forUnmarshaling);
 
-void marshal_VkMutableDescriptorTypeListVALVE(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkMutableDescriptorTypeListVALVE* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT,
+                      marshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT,
+                      unmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)
+
+void marshal_VkMutableDescriptorTypeListEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkMutableDescriptorTypeListEXT* forMarshaling);
+
+void unmarshal_VkMutableDescriptorTypeListEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkMutableDescriptorTypeListEXT* forUnmarshaling);
 
-void unmarshal_VkMutableDescriptorTypeListVALVE(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkMutableDescriptorTypeListVALVE* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkMutableDescriptorTypeListEXT,
+                      marshal_VkMutableDescriptorTypeListVALVE)
 
-void marshal_VkMutableDescriptorTypeCreateInfoVALVE(
+DEFINE_ALIAS_FUNCTION(unmarshal_VkMutableDescriptorTypeListEXT,
+                      unmarshal_VkMutableDescriptorTypeListVALVE)
+
+void marshal_VkMutableDescriptorTypeCreateInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkMutableDescriptorTypeCreateInfoVALVE* forMarshaling);
+    const VkMutableDescriptorTypeCreateInfoEXT* forMarshaling);
 
-void unmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
+void unmarshal_VkMutableDescriptorTypeCreateInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkMutableDescriptorTypeCreateInfoVALVE* forUnmarshaling);
+    VkMutableDescriptorTypeCreateInfoEXT* forUnmarshaling);
+
+DEFINE_ALIAS_FUNCTION(marshal_VkMutableDescriptorTypeCreateInfoEXT,
+                      marshal_VkMutableDescriptorTypeCreateInfoVALVE)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkMutableDescriptorTypeCreateInfoEXT,
+                      unmarshal_VkMutableDescriptorTypeCreateInfoVALVE)
 
 #endif
 #ifdef VK_EXT_vertex_input_dynamic_state
@@ -6357,6 +7295,42 @@ void unmarshal_VkPhysicalDeviceDrmPropertiesEXT(VulkanStream* vkStream, VkStruct
                                                 VkPhysicalDeviceDrmPropertiesEXT* forUnmarshaling);
 
 #endif
+#ifdef VK_EXT_device_address_binding_report
+void marshal_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT* forUnmarshaling);
+
+void marshal_VkDeviceAddressBindingCallbackDataEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDeviceAddressBindingCallbackDataEXT* forMarshaling);
+
+void unmarshal_VkDeviceAddressBindingCallbackDataEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceAddressBindingCallbackDataEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_depth_clip_control
+void marshal_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClipControlFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDepthClipControlFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelineViewportDepthClipControlCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineViewportDepthClipControlCreateInfoEXT* forUnmarshaling);
+
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 void marshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -6552,6 +7526,55 @@ void unmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
 
 #define OP_vkGetMemoryRemoteAddressNV 256917597
 #endif
+#ifdef VK_EXT_pipeline_properties
+DEFINE_ALIAS_FUNCTION(marshal_VkPipelineInfoKHR, marshal_VkPipelineInfoEXT)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineInfoKHR, unmarshal_VkPipelineInfoEXT)
+
+void marshal_VkPipelinePropertiesIdentifierEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelinePropertiesIdentifierEXT* forMarshaling);
+
+void unmarshal_VkPipelinePropertiesIdentifierEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelinePropertiesIdentifierEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePipelinePropertiesFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT* forUnmarshaling);
+
+#define OP_vkGetPipelinePropertiesEXT 243590447
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+void marshal_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* forUnmarshaling);
+
+void marshal_VkSubpassResolvePerformanceQueryEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSubpassResolvePerformanceQueryEXT* forMarshaling);
+
+void unmarshal_VkSubpassResolvePerformanceQueryEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSubpassResolvePerformanceQueryEXT* forUnmarshaling);
+
+void marshal_VkMultisampledRenderToSingleSampledInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkMultisampledRenderToSingleSampledInfoEXT* forMarshaling);
+
+void unmarshal_VkMultisampledRenderToSingleSampledInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkMultisampledRenderToSingleSampledInfoEXT* forUnmarshaling);
+
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void marshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -6596,6 +7619,16 @@ void unmarshal_VkPipelineColorWriteCreateInfoEXT(
 
 #define OP_vkCmdSetColorWriteEnableEXT 202223297
 #endif
+#ifdef VK_EXT_primitives_generated_query
+void marshal_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* forUnmarshaling);
+
+#endif
 #ifdef VK_GOOGLE_gfxstream
 void marshal_VkImportColorBufferGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                        const VkImportColorBufferGOOGLE* forMarshaling);
@@ -6637,23 +7670,36 @@ void unmarshal_VkCreateBlobGOOGLE(VulkanStream* vkStream, VkStructureType rootTy
 #define OP_vkQueueSignalReleaseImageANDROIDAsyncGOOGLE 243985229
 #define OP_vkQueueFlushCommandsFromAuxMemoryGOOGLE 290633483
 #define OP_vkGetBlobGOOGLE 20341
+#define OP_vkUpdateDescriptorSetWithTemplateSized2GOOGLE 244782974
 #endif
 #ifdef VK_EXT_global_priority_query
-void marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forMarshaling);
+DEFINE_ALIAS_FUNCTION(marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR,
+                      marshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT)
 
-void unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forUnmarshaling);
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR,
+                      unmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT)
+
+DEFINE_ALIAS_FUNCTION(marshal_VkQueueFamilyGlobalPriorityPropertiesKHR,
+                      marshal_VkQueueFamilyGlobalPriorityPropertiesEXT)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkQueueFamilyGlobalPriorityPropertiesKHR,
+                      unmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT)
 
-void marshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
+#endif
+#ifdef VK_EXT_image_view_min_lod
+void marshal_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    const VkQueueFamilyGlobalPriorityPropertiesEXT* forMarshaling);
+    const VkPhysicalDeviceImageViewMinLodFeaturesEXT* forMarshaling);
 
-void unmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
+void unmarshal_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkQueueFamilyGlobalPriorityPropertiesEXT* forUnmarshaling);
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT* forUnmarshaling);
+
+void marshal_VkImageViewMinLodCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkImageViewMinLodCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkImageViewMinLodCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkImageViewMinLodCreateInfoEXT* forUnmarshaling);
 
 #endif
 #ifdef VK_EXT_multi_draw
@@ -6688,8 +7734,182 @@ void unmarshal_VkMultiDrawIndexedInfoEXT(VulkanStream* vkStream, VkStructureType
 #define OP_vkCmdDrawMultiEXT 263629455
 #define OP_vkCmdDrawMultiIndexedEXT 284764463
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+void marshal_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_shader_tile_image
+void marshal_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderTileImageFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderTileImageFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderTileImagePropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderTileImagePropertiesEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_opacity_micromap
+void marshal_VkMicromapUsageEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                const VkMicromapUsageEXT* forMarshaling);
+
+void unmarshal_VkMicromapUsageEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                  VkMicromapUsageEXT* forUnmarshaling);
+
+void marshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                      const VkDeviceOrHostAddressKHR* forMarshaling);
+
+void unmarshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkDeviceOrHostAddressKHR* forUnmarshaling);
+
+void marshal_VkMicromapBuildInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                    const VkMicromapBuildInfoEXT* forMarshaling);
+
+void unmarshal_VkMicromapBuildInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      VkMicromapBuildInfoEXT* forUnmarshaling);
+
+void marshal_VkMicromapCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     const VkMicromapCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkMicromapCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkMicromapCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceOpacityMicromapFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceOpacityMicromapPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT* forUnmarshaling);
+
+void marshal_VkMicromapVersionInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                      const VkMicromapVersionInfoEXT* forMarshaling);
+
+void unmarshal_VkMicromapVersionInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkMicromapVersionInfoEXT* forUnmarshaling);
+
+void marshal_VkCopyMicromapToMemoryInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkCopyMicromapToMemoryInfoEXT* forMarshaling);
+
+void unmarshal_VkCopyMicromapToMemoryInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkCopyMicromapToMemoryInfoEXT* forUnmarshaling);
+
+void marshal_VkCopyMemoryToMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkCopyMemoryToMicromapInfoEXT* forMarshaling);
+
+void unmarshal_VkCopyMemoryToMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkCopyMemoryToMicromapInfoEXT* forUnmarshaling);
+
+void marshal_VkCopyMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                   const VkCopyMicromapInfoEXT* forMarshaling);
+
+void unmarshal_VkCopyMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkCopyMicromapInfoEXT* forUnmarshaling);
+
+void marshal_VkMicromapBuildSizesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkMicromapBuildSizesInfoEXT* forMarshaling);
+
+void unmarshal_VkMicromapBuildSizesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkMicromapBuildSizesInfoEXT* forUnmarshaling);
+
+void marshal_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkAccelerationStructureTrianglesOpacityMicromapEXT* forMarshaling);
+
+void unmarshal_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkAccelerationStructureTrianglesOpacityMicromapEXT* forUnmarshaling);
+
+void marshal_VkMicromapTriangleEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                   const VkMicromapTriangleEXT* forMarshaling);
+
+void unmarshal_VkMicromapTriangleEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkMicromapTriangleEXT* forUnmarshaling);
+
+#define OP_vkCreateMicromapEXT 259761575
+#define OP_vkDestroyMicromapEXT 242737967
+#define OP_vkCmdBuildMicromapsEXT 208359339
+#define OP_vkBuildMicromapsEXT 241546750
+#define OP_vkCopyMicromapEXT 270454822
+#define OP_vkCopyMicromapToMemoryEXT 267213862
+#define OP_vkCopyMemoryToMicromapEXT 292237056
+#define OP_vkWriteMicromapsPropertiesEXT 208543737
+#define OP_vkCmdCopyMicromapEXT 288267635
+#define OP_vkCmdCopyMicromapToMemoryEXT 234439088
+#define OP_vkCmdCopyMemoryToMicromapEXT 281369443
+#define OP_vkCmdWriteMicromapsPropertiesEXT 210288632
+#define OP_vkGetDeviceMicromapCompatibilityEXT 282914497
+#define OP_vkGetMicromapBuildSizesEXT 290917918
+#endif
+#ifdef VK_NV_displacement_micromap
+void marshal_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV* forUnmarshaling);
+
+void marshal_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkAccelerationStructureTrianglesDisplacementMicromapNV* forMarshaling);
+
+void unmarshal_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkAccelerationStructureTrianglesDisplacementMicromapNV* forUnmarshaling);
+
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void marshal_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* forUnmarshaling);
+
+#define OP_vkCmdDrawClusterHUAWEI 253709648
+#define OP_vkCmdDrawClusterIndirectHUAWEI 210642983
+#endif
 #ifdef VK_EXT_border_color_swizzle
 void marshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -6719,13 +7939,607 @@ void unmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
 
 #define OP_vkSetDeviceMemoryPriorityEXT 223991870
 #endif
-#ifdef VK_KHR_acceleration_structure
-void marshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                      const VkDeviceOrHostAddressKHR* forMarshaling);
+#ifdef VK_ARM_shader_core_properties
+void marshal_VkPhysicalDeviceShaderCorePropertiesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderCorePropertiesARM* forMarshaling);
 
-void unmarshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                        VkDeviceOrHostAddressKHR* forUnmarshaling);
+void unmarshal_VkPhysicalDeviceShaderCorePropertiesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderCorePropertiesARM* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+void marshal_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* forUnmarshaling);
+
+void marshal_VkImageViewSlicedCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkImageViewSlicedCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkImageViewSlicedCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkImageViewSlicedCreateInfoEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void marshal_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* forUnmarshaling);
+
+void marshal_VkDescriptorSetBindingReferenceVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDescriptorSetBindingReferenceVALVE* forMarshaling);
+
+void unmarshal_VkDescriptorSetBindingReferenceVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorSetBindingReferenceVALVE* forUnmarshaling);
+
+void marshal_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDescriptorSetLayoutHostMappingInfoVALVE* forMarshaling);
+
+void unmarshal_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorSetLayoutHostMappingInfoVALVE* forUnmarshaling);
+
+#define OP_vkGetDescriptorSetLayoutHostMappingInfoVALVE 296524818
+#define OP_vkGetDescriptorSetHostMappingVALVE 280470843
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+void marshal_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+void marshal_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+void marshal_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* forUnmarshaling);
+
+void marshal_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* forMarshaling);
+
+void unmarshal_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void marshal_VkCopyMemoryIndirectCommandNV(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkCopyMemoryIndirectCommandNV* forMarshaling);
+
+void unmarshal_VkCopyMemoryIndirectCommandNV(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkCopyMemoryIndirectCommandNV* forUnmarshaling);
+
+void marshal_VkCopyMemoryToImageIndirectCommandNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkCopyMemoryToImageIndirectCommandNV* forMarshaling);
+
+void unmarshal_VkCopyMemoryToImageIndirectCommandNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkCopyMemoryToImageIndirectCommandNV* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* forUnmarshaling);
+
+#define OP_vkCmdCopyMemoryIndirectNV 244937609
+#define OP_vkCmdCopyMemoryToImageIndirectNV 277100806
+#endif
+#ifdef VK_NV_memory_decompression
+void marshal_VkDecompressMemoryRegionNV(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkDecompressMemoryRegionNV* forMarshaling);
+
+void unmarshal_VkDecompressMemoryRegionNV(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkDecompressMemoryRegionNV* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMemoryDecompressionFeaturesNV* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV* forUnmarshaling);
+
+#define OP_vkCmdDecompressMemoryNV 220223048
+#define OP_vkCmdDecompressMemoryIndirectCountNV 284140092
+#endif
+#ifdef VK_NV_linear_color_attachment
+void marshal_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* forUnmarshaling);
+
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+void marshal_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_QCOM_image_processing
+void marshal_VkImageViewSampleWeightCreateInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkImageViewSampleWeightCreateInfoQCOM* forMarshaling);
+
+void unmarshal_VkImageViewSampleWeightCreateInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageViewSampleWeightCreateInfoQCOM* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceImageProcessingFeaturesQCOM* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageProcessingFeaturesQCOM* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceImageProcessingPropertiesQCOM* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageProcessingPropertiesQCOM* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void marshal_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* forUnmarshaling);
+
+void marshal_VkColorBlendEquationEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     const VkColorBlendEquationEXT* forMarshaling);
+
+void unmarshal_VkColorBlendEquationEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkColorBlendEquationEXT* forUnmarshaling);
+
+void marshal_VkColorBlendAdvancedEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     const VkColorBlendAdvancedEXT* forMarshaling);
+
+void unmarshal_VkColorBlendAdvancedEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkColorBlendAdvancedEXT* forUnmarshaling);
+
+#define OP_vkCmdSetTessellationDomainOriginEXT 264837311
+#define OP_vkCmdSetDepthClampEnableEXT 251152142
+#define OP_vkCmdSetPolygonModeEXT 244360005
+#define OP_vkCmdSetRasterizationSamplesEXT 200185328
+#define OP_vkCmdSetSampleMaskEXT 205683579
+#define OP_vkCmdSetAlphaToCoverageEnableEXT 250119881
+#define OP_vkCmdSetAlphaToOneEnableEXT 290007127
+#define OP_vkCmdSetLogicOpEnableEXT 282779034
+#define OP_vkCmdSetColorBlendEnableEXT 295219919
+#define OP_vkCmdSetColorBlendEquationEXT 223529166
+#define OP_vkCmdSetColorWriteMaskEXT 228446899
+#define OP_vkCmdSetRasterizationStreamEXT 204993319
+#define OP_vkCmdSetConservativeRasterizationModeEXT 293408379
+#define OP_vkCmdSetExtraPrimitiveOverestimationSizeEXT 291579247
+#define OP_vkCmdSetDepthClipEnableEXT 283535332
+#define OP_vkCmdSetSampleLocationsEnableEXT 268974525
+#define OP_vkCmdSetColorBlendAdvancedEXT 202772488
+#define OP_vkCmdSetProvokingVertexModeEXT 251550033
+#define OP_vkCmdSetLineRasterizationModeEXT 294038690
+#define OP_vkCmdSetLineStippleEnableEXT 225451186
+#define OP_vkCmdSetDepthClipNegativeOneToOneEXT 278908707
+#define OP_vkCmdSetViewportWScalingEnableNV 204717634
+#define OP_vkCmdSetViewportSwizzleNV 262192878
+#define OP_vkCmdSetCoverageToColorEnableNV 274778288
+#define OP_vkCmdSetCoverageToColorLocationNV 244968701
+#define OP_vkCmdSetCoverageModulationModeNV 225061936
+#define OP_vkCmdSetCoverageModulationTableEnableNV 285825505
+#define OP_vkCmdSetCoverageModulationTableNV 259749057
+#define OP_vkCmdSetShadingRateImageEnableNV 299919487
+#define OP_vkCmdSetRepresentativeFragmentTestEnableNV 244853060
+#define OP_vkCmdSetCoverageReductionModeNV 259685321
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+void marshal_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* forUnmarshaling);
+
+void marshal_VkRenderPassCreationControlEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkRenderPassCreationControlEXT* forMarshaling);
+
+void unmarshal_VkRenderPassCreationControlEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkRenderPassCreationControlEXT* forUnmarshaling);
+
+void marshal_VkRenderPassCreationFeedbackInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkRenderPassCreationFeedbackInfoEXT* forMarshaling);
+
+void unmarshal_VkRenderPassCreationFeedbackInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassCreationFeedbackInfoEXT* forUnmarshaling);
+
+void marshal_VkRenderPassCreationFeedbackCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkRenderPassCreationFeedbackCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkRenderPassCreationFeedbackCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassCreationFeedbackCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkRenderPassSubpassFeedbackInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkRenderPassSubpassFeedbackInfoEXT* forMarshaling);
+
+void unmarshal_VkRenderPassSubpassFeedbackInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassSubpassFeedbackInfoEXT* forUnmarshaling);
+
+void marshal_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkRenderPassSubpassFeedbackCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassSubpassFeedbackCreateInfoEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+void marshal_VkDirectDriverLoadingInfoLUNARG(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkDirectDriverLoadingInfoLUNARG* forMarshaling);
+
+void unmarshal_VkDirectDriverLoadingInfoLUNARG(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkDirectDriverLoadingInfoLUNARG* forUnmarshaling);
+
+void marshal_VkDirectDriverLoadingListLUNARG(VulkanStream* vkStream, VkStructureType rootType,
+                                             const VkDirectDriverLoadingListLUNARG* forMarshaling);
+
+void unmarshal_VkDirectDriverLoadingListLUNARG(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkDirectDriverLoadingListLUNARG* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void marshal_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* forUnmarshaling);
+
+void marshal_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* forMarshaling);
 
+void unmarshal_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkShaderModuleIdentifierEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                         const VkShaderModuleIdentifierEXT* forMarshaling);
+
+void unmarshal_VkShaderModuleIdentifierEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkShaderModuleIdentifierEXT* forUnmarshaling);
+
+#define OP_vkGetShaderModuleIdentifierEXT 288535751
+#define OP_vkGetShaderModuleCreateInfoIdentifierEXT 214340596
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+void marshal_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceOpticalFlowFeaturesNV* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpticalFlowFeaturesNV* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceOpticalFlowPropertiesNV* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpticalFlowPropertiesNV* forUnmarshaling);
+
+void marshal_VkOpticalFlowImageFormatInfoNV(VulkanStream* vkStream, VkStructureType rootType,
+                                            const VkOpticalFlowImageFormatInfoNV* forMarshaling);
+
+void unmarshal_VkOpticalFlowImageFormatInfoNV(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkOpticalFlowImageFormatInfoNV* forUnmarshaling);
+
+void marshal_VkOpticalFlowImageFormatPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkOpticalFlowImageFormatPropertiesNV* forMarshaling);
+
+void unmarshal_VkOpticalFlowImageFormatPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpticalFlowImageFormatPropertiesNV* forUnmarshaling);
+
+void marshal_VkOpticalFlowSessionCreateInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkOpticalFlowSessionCreateInfoNV* forMarshaling);
+
+void unmarshal_VkOpticalFlowSessionCreateInfoNV(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkOpticalFlowSessionCreateInfoNV* forUnmarshaling);
+
+void marshal_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkOpticalFlowSessionCreatePrivateDataInfoNV* forMarshaling);
+
+void unmarshal_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpticalFlowSessionCreatePrivateDataInfoNV* forUnmarshaling);
+
+void marshal_VkOpticalFlowExecuteInfoNV(VulkanStream* vkStream, VkStructureType rootType,
+                                        const VkOpticalFlowExecuteInfoNV* forMarshaling);
+
+void unmarshal_VkOpticalFlowExecuteInfoNV(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkOpticalFlowExecuteInfoNV* forUnmarshaling);
+
+#define OP_vkGetPhysicalDeviceOpticalFlowImageFormatsNV 291249090
+#define OP_vkCreateOpticalFlowSessionNV 203493394
+#define OP_vkDestroyOpticalFlowSessionNV 255326418
+#define OP_vkBindOpticalFlowSessionImageNV 216400621
+#define OP_vkCmdOpticalFlowExecuteNV 218031512
+#endif
+#ifdef VK_EXT_legacy_dithering
+void marshal_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceLegacyDitheringFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+void marshal_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_shader_object
+void marshal_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderObjectFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderObjectFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderObjectPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderObjectPropertiesEXT* forUnmarshaling);
+
+void marshal_VkShaderCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                   const VkShaderCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkShaderCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkShaderCreateInfoEXT* forUnmarshaling);
+
+DEFINE_ALIAS_FUNCTION(marshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      marshal_VkShaderRequiredSubgroupSizeCreateInfoEXT)
+
+DEFINE_ALIAS_FUNCTION(unmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      unmarshal_VkShaderRequiredSubgroupSizeCreateInfoEXT)
+
+#define OP_vkCreateShadersEXT 280894162
+#define OP_vkDestroyShaderEXT 242383899
+#define OP_vkGetShaderBinaryDataEXT 271272626
+#define OP_vkCmdBindShadersEXT 269580563
+#endif
+#ifdef VK_QCOM_tile_properties
+void marshal_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceTilePropertiesFeaturesQCOM* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceTilePropertiesFeaturesQCOM* forUnmarshaling);
+
+void marshal_VkTilePropertiesQCOM(VulkanStream* vkStream, VkStructureType rootType,
+                                  const VkTilePropertiesQCOM* forMarshaling);
+
+void unmarshal_VkTilePropertiesQCOM(VulkanStream* vkStream, VkStructureType rootType,
+                                    VkTilePropertiesQCOM* forUnmarshaling);
+
+#define OP_vkGetFramebufferTilePropertiesQCOM 248471090
+#define OP_vkGetDynamicRenderingTilePropertiesQCOM 240209057
+#endif
+#ifdef VK_SEC_amigo_profiling
+void marshal_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceAmigoProfilingFeaturesSEC* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAmigoProfilingFeaturesSEC* forUnmarshaling);
+
+void marshal_VkAmigoProfilingSubmitInfoSEC(VulkanStream* vkStream, VkStructureType rootType,
+                                           const VkAmigoProfilingSubmitInfoSEC* forMarshaling);
+
+void unmarshal_VkAmigoProfilingSubmitInfoSEC(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkAmigoProfilingSubmitInfoSEC* forUnmarshaling);
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+void marshal_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* forUnmarshaling);
+
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+void marshal_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+void marshal_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+void marshal_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* forUnmarshaling);
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+void marshal_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* forUnmarshaling);
+
+void marshal_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* forMarshaling);
+
+void unmarshal_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* forUnmarshaling);
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+void marshal_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* forUnmarshaling);
+
+#define OP_vkCmdSetAttachmentFeedbackLoopEnableEXT 286531212
+#endif
+#ifdef VK_KHR_acceleration_structure
 void marshal_VkAccelerationStructureBuildRangeInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
     const VkAccelerationStructureBuildRangeInfoKHR* forMarshaling);
@@ -6949,6 +8763,35 @@ void unmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
     VkPhysicalDeviceRayQueryFeaturesKHR* forUnmarshaling);
 
 #endif
+#ifdef VK_EXT_mesh_shader
+void marshal_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMeshShaderFeaturesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMeshShaderFeaturesEXT* forUnmarshaling);
+
+void marshal_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkPhysicalDeviceMeshShaderPropertiesEXT* forMarshaling);
+
+void unmarshal_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMeshShaderPropertiesEXT* forUnmarshaling);
+
+void marshal_VkDrawMeshTasksIndirectCommandEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    const VkDrawMeshTasksIndirectCommandEXT* forMarshaling);
+
+void unmarshal_VkDrawMeshTasksIndirectCommandEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDrawMeshTasksIndirectCommandEXT* forUnmarshaling);
+
+#define OP_vkCmdDrawMeshTasksEXT 285389206
+#define OP_vkCmdDrawMeshTasksIndirectEXT 223766634
+#define OP_vkCmdDrawMeshTasksIndirectCountEXT 251700466
+#endif
 const char* api_opcode_to_string(const uint32_t opcode);
 
 #define OP_vkFirst_old 20000
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp b/stream-servers/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
index c49f4783..9da51718 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_reserved_marshaling
 //
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (impl) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -8100,6 +8100,2215 @@ void reservedunmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
 }
 
 #endif
+#ifdef VK_VERSION_1_3
+void reservedunmarshal_VkPhysicalDeviceVulkan13Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceVulkan13Features* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->robustImageAccess, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->inlineUniformBlock, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->pipelineCreationCacheControl, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->privateData, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->shaderDemoteToHelperInvocation, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->shaderTerminateInvocation, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->subgroupSizeControl, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->computeFullSubgroups, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->synchronization2, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->textureCompressionASTC_HDR, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->shaderZeroInitializeWorkgroupMemory, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->dynamicRendering, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->shaderIntegerDotProduct, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->maintenance4, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceVulkan13Properties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceVulkan13Properties* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->minSubgroupSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxSubgroupSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxComputeWorkgroupSubgroups, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((VkShaderStageFlags*)&forUnmarshaling->requiredSubgroupSizeStages, *ptr,
+           sizeof(VkShaderStageFlags));
+    *ptr += sizeof(VkShaderStageFlags);
+    memcpy((uint32_t*)&forUnmarshaling->maxInlineUniformBlockSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInlineUniformBlocks, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
+           *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxDescriptorSetInlineUniformBlocks, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxInlineUniformTotalSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct8BitUnsignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct8BitSignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct8BitMixedSignednessAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedSignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct16BitUnsignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct16BitSignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct16BitMixedSignednessAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct32BitUnsignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct32BitSignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct32BitMixedSignednessAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct64BitUnsignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct64BitSignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct64BitMixedSignednessAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
+        *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
+        *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
+        *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
+        *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
+        *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkDeviceSize*)&forUnmarshaling->storageTexelBufferOffsetAlignmentBytes, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkBool32*)&forUnmarshaling->storageTexelBufferOffsetSingleTexelAlignment, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkDeviceSize*)&forUnmarshaling->uniformTexelBufferOffsetAlignmentBytes, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkBool32*)&forUnmarshaling->uniformTexelBufferOffsetSingleTexelAlignment, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkDeviceSize*)&forUnmarshaling->maxBufferSize, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+}
+
+void reservedunmarshal_VkPipelineCreationFeedback(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkPipelineCreationFeedback* forUnmarshaling,
+                                                  uint8_t** ptr) {
+    memcpy((VkPipelineCreationFeedbackFlags*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkPipelineCreationFeedbackFlags));
+    *ptr += sizeof(VkPipelineCreationFeedbackFlags);
+    memcpy((uint64_t*)&forUnmarshaling->duration, *ptr, sizeof(uint64_t));
+    *ptr += sizeof(uint64_t);
+}
+
+void reservedunmarshal_VkPipelineCreationFeedbackCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineCreationFeedbackCreateInfo* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pPipelineCreationFeedback,
+                    sizeof(VkPipelineCreationFeedback));
+    reservedunmarshal_VkPipelineCreationFeedback(
+        vkStream, rootType,
+        (VkPipelineCreationFeedback*)(forUnmarshaling->pPipelineCreationFeedback), ptr);
+    memcpy((uint32_t*)&forUnmarshaling->pipelineStageCreationFeedbackCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pPipelineStageCreationFeedbacks,
+        forUnmarshaling->pipelineStageCreationFeedbackCount * sizeof(VkPipelineCreationFeedback));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pipelineStageCreationFeedbackCount; ++i) {
+        reservedunmarshal_VkPipelineCreationFeedback(
+            vkStream, rootType,
+            (VkPipelineCreationFeedback*)(forUnmarshaling->pPipelineStageCreationFeedbacks + i),
+            ptr);
+    }
+}
+
+void reservedunmarshal_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderTerminateInvocationFeatures* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->shaderTerminateInvocation, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceToolProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceToolProperties* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((char*)forUnmarshaling->name, *ptr, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    *ptr += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
+    memcpy((char*)forUnmarshaling->version, *ptr, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    *ptr += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
+    memcpy((VkToolPurposeFlags*)&forUnmarshaling->purposes, *ptr, sizeof(VkToolPurposeFlags));
+    *ptr += sizeof(VkToolPurposeFlags);
+    memcpy((char*)forUnmarshaling->description, *ptr, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
+    memcpy((char*)forUnmarshaling->layer, *ptr, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
+    *ptr += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
+}
+
+void reservedunmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->shaderDemoteToHelperInvocation, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDevicePrivateDataFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePrivateDataFeatures* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->privateData, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkDevicePrivateDataCreateInfo(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkDevicePrivateDataCreateInfo* forUnmarshaling,
+                                                     uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->privateDataSlotRequestCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkPrivateDataSlotCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkPrivateDataSlotCreateInfo* forUnmarshaling,
+                                                   uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkPrivateDataSlotCreateFlags*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkPrivateDataSlotCreateFlags));
+    *ptr += sizeof(VkPrivateDataSlotCreateFlags);
+}
+
+void reservedunmarshal_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineCreationCacheControlFeatures* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->pipelineCreationCacheControl, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkMemoryBarrier2* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkPipelineStageFlags2*)&forUnmarshaling->srcStageMask, *ptr,
+           sizeof(VkPipelineStageFlags2));
+    *ptr += sizeof(VkPipelineStageFlags2);
+    memcpy((VkAccessFlags2*)&forUnmarshaling->srcAccessMask, *ptr, sizeof(VkAccessFlags2));
+    *ptr += sizeof(VkAccessFlags2);
+    memcpy((VkPipelineStageFlags2*)&forUnmarshaling->dstStageMask, *ptr,
+           sizeof(VkPipelineStageFlags2));
+    *ptr += sizeof(VkPipelineStageFlags2);
+    memcpy((VkAccessFlags2*)&forUnmarshaling->dstAccessMask, *ptr, sizeof(VkAccessFlags2));
+    *ptr += sizeof(VkAccessFlags2);
+}
+
+void reservedunmarshal_VkBufferMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkBufferMemoryBarrier2* forUnmarshaling,
+                                              uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkPipelineStageFlags2*)&forUnmarshaling->srcStageMask, *ptr,
+           sizeof(VkPipelineStageFlags2));
+    *ptr += sizeof(VkPipelineStageFlags2);
+    memcpy((VkAccessFlags2*)&forUnmarshaling->srcAccessMask, *ptr, sizeof(VkAccessFlags2));
+    *ptr += sizeof(VkAccessFlags2);
+    memcpy((VkPipelineStageFlags2*)&forUnmarshaling->dstStageMask, *ptr,
+           sizeof(VkPipelineStageFlags2));
+    *ptr += sizeof(VkPipelineStageFlags2);
+    memcpy((VkAccessFlags2*)&forUnmarshaling->dstAccessMask, *ptr, sizeof(VkAccessFlags2));
+    *ptr += sizeof(VkAccessFlags2);
+    memcpy((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkBuffer*)&forUnmarshaling->buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+    memcpy((VkDeviceSize*)&forUnmarshaling->offset, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceSize*)&forUnmarshaling->size, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+}
+
+void reservedunmarshal_VkImageMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkImageMemoryBarrier2* forUnmarshaling,
+                                             uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkPipelineStageFlags2*)&forUnmarshaling->srcStageMask, *ptr,
+           sizeof(VkPipelineStageFlags2));
+    *ptr += sizeof(VkPipelineStageFlags2);
+    memcpy((VkAccessFlags2*)&forUnmarshaling->srcAccessMask, *ptr, sizeof(VkAccessFlags2));
+    *ptr += sizeof(VkAccessFlags2);
+    memcpy((VkPipelineStageFlags2*)&forUnmarshaling->dstStageMask, *ptr,
+           sizeof(VkPipelineStageFlags2));
+    *ptr += sizeof(VkPipelineStageFlags2);
+    memcpy((VkAccessFlags2*)&forUnmarshaling->dstAccessMask, *ptr, sizeof(VkAccessFlags2));
+    *ptr += sizeof(VkAccessFlags2);
+    memcpy((VkImageLayout*)&forUnmarshaling->oldLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    memcpy((VkImageLayout*)&forUnmarshaling->newLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    memcpy((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+    reservedunmarshal_VkImageSubresourceRange(
+        vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange), ptr);
+}
+
+void reservedunmarshal_VkDependencyInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkDependencyInfo* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkDependencyFlags*)&forUnmarshaling->dependencyFlags, *ptr, sizeof(VkDependencyFlags));
+    *ptr += sizeof(VkDependencyFlags);
+    memcpy((uint32_t*)&forUnmarshaling->memoryBarrierCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pMemoryBarriers,
+                    forUnmarshaling->memoryBarrierCount * sizeof(const VkMemoryBarrier2));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->memoryBarrierCount; ++i) {
+        reservedunmarshal_VkMemoryBarrier2(
+            vkStream, rootType, (VkMemoryBarrier2*)(forUnmarshaling->pMemoryBarriers + i), ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->bufferMemoryBarrierCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pBufferMemoryBarriers,
+        forUnmarshaling->bufferMemoryBarrierCount * sizeof(const VkBufferMemoryBarrier2));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferMemoryBarrierCount; ++i) {
+        reservedunmarshal_VkBufferMemoryBarrier2(
+            vkStream, rootType,
+            (VkBufferMemoryBarrier2*)(forUnmarshaling->pBufferMemoryBarriers + i), ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->imageMemoryBarrierCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pImageMemoryBarriers,
+                    forUnmarshaling->imageMemoryBarrierCount * sizeof(const VkImageMemoryBarrier2));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageMemoryBarrierCount; ++i) {
+        reservedunmarshal_VkImageMemoryBarrier2(
+            vkStream, rootType, (VkImageMemoryBarrier2*)(forUnmarshaling->pImageMemoryBarriers + i),
+            ptr);
+    }
+}
+
+void reservedunmarshal_VkSemaphoreSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkSemaphoreSubmitInfo* forUnmarshaling,
+                                             uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkSemaphore*)&forUnmarshaling->semaphore =
+        (VkSemaphore)unbox_VkSemaphore((VkSemaphore)(*&cgen_var_0));
+    memcpy((uint64_t*)&forUnmarshaling->value, *ptr, sizeof(uint64_t));
+    *ptr += sizeof(uint64_t);
+    memcpy((VkPipelineStageFlags2*)&forUnmarshaling->stageMask, *ptr,
+           sizeof(VkPipelineStageFlags2));
+    *ptr += sizeof(VkPipelineStageFlags2);
+    memcpy((uint32_t*)&forUnmarshaling->deviceIndex, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkCommandBufferSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                                 VkCommandBufferSubmitInfo* forUnmarshaling,
+                                                 uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkCommandBuffer*)&forUnmarshaling->commandBuffer =
+        (VkCommandBuffer)unbox_VkCommandBuffer((VkCommandBuffer)(*&cgen_var_0));
+    memcpy((uint32_t*)&forUnmarshaling->deviceMask, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkSubmitInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkSubmitInfo2* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkSubmitFlags*)&forUnmarshaling->flags, *ptr, sizeof(VkSubmitFlags));
+    *ptr += sizeof(VkSubmitFlags);
+    memcpy((uint32_t*)&forUnmarshaling->waitSemaphoreInfoCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pWaitSemaphoreInfos,
+                    forUnmarshaling->waitSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfo));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->waitSemaphoreInfoCount; ++i) {
+        reservedunmarshal_VkSemaphoreSubmitInfo(
+            vkStream, rootType, (VkSemaphoreSubmitInfo*)(forUnmarshaling->pWaitSemaphoreInfos + i),
+            ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->commandBufferInfoCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pCommandBufferInfos,
+        forUnmarshaling->commandBufferInfoCount * sizeof(const VkCommandBufferSubmitInfo));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->commandBufferInfoCount; ++i) {
+        reservedunmarshal_VkCommandBufferSubmitInfo(
+            vkStream, rootType,
+            (VkCommandBufferSubmitInfo*)(forUnmarshaling->pCommandBufferInfos + i), ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->signalSemaphoreInfoCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pSignalSemaphoreInfos,
+        forUnmarshaling->signalSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfo));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->signalSemaphoreInfoCount; ++i) {
+        reservedunmarshal_VkSemaphoreSubmitInfo(
+            vkStream, rootType,
+            (VkSemaphoreSubmitInfo*)(forUnmarshaling->pSignalSemaphoreInfos + i), ptr);
+    }
+}
+
+void reservedunmarshal_VkPhysicalDeviceSynchronization2Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSynchronization2Features* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->synchronization2, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->shaderZeroInitializeWorkgroupMemory, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceImageRobustnessFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageRobustnessFeatures* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->robustImageAccess, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkBufferCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkBufferCopy2* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkDeviceSize*)&forUnmarshaling->srcOffset, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceSize*)&forUnmarshaling->dstOffset, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceSize*)&forUnmarshaling->size, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+}
+
+void reservedunmarshal_VkCopyBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkCopyBufferInfo2* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkBuffer*)&forUnmarshaling->srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+    uint64_t cgen_var_1;
+    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkBuffer*)&forUnmarshaling->dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkBufferCopy2));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+        reservedunmarshal_VkBufferCopy2(vkStream, rootType,
+                                        (VkBufferCopy2*)(forUnmarshaling->pRegions + i), ptr);
+    }
+}
+
+void reservedunmarshal_VkImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                                    VkImageCopy2* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    reservedunmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource), ptr);
+    reservedunmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset),
+                                 ptr);
+    reservedunmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource), ptr);
+    reservedunmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset),
+                                 ptr);
+    reservedunmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent), ptr);
+}
+
+void reservedunmarshal_VkCopyImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkCopyImageInfo2* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+    memcpy((VkImageLayout*)&forUnmarshaling->srcImageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    uint64_t cgen_var_1;
+    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
+    memcpy((VkImageLayout*)&forUnmarshaling->dstImageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkImageCopy2));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+        reservedunmarshal_VkImageCopy2(vkStream, rootType,
+                                       (VkImageCopy2*)(forUnmarshaling->pRegions + i), ptr);
+    }
+}
+
+void reservedunmarshal_VkBufferImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkBufferImageCopy2* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkDeviceSize*)&forUnmarshaling->bufferOffset, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((uint32_t*)&forUnmarshaling->bufferRowLength, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->bufferImageHeight, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    reservedunmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource), ptr);
+    reservedunmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset),
+                                 ptr);
+    reservedunmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent),
+                                 ptr);
+}
+
+void reservedunmarshal_VkCopyBufferToImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkCopyBufferToImageInfo2* forUnmarshaling,
+                                                uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkBuffer*)&forUnmarshaling->srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+    uint64_t cgen_var_1;
+    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
+    memcpy((VkImageLayout*)&forUnmarshaling->dstImageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkBufferImageCopy2));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+        reservedunmarshal_VkBufferImageCopy2(
+            vkStream, rootType, (VkBufferImageCopy2*)(forUnmarshaling->pRegions + i), ptr);
+    }
+}
+
+void reservedunmarshal_VkCopyImageToBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkCopyImageToBufferInfo2* forUnmarshaling,
+                                                uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+    memcpy((VkImageLayout*)&forUnmarshaling->srcImageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    uint64_t cgen_var_1;
+    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkBuffer*)&forUnmarshaling->dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
+    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkBufferImageCopy2));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+        reservedunmarshal_VkBufferImageCopy2(
+            vkStream, rootType, (VkBufferImageCopy2*)(forUnmarshaling->pRegions + i), ptr);
+    }
+}
+
+void reservedunmarshal_VkImageBlit2(VulkanStream* vkStream, VkStructureType rootType,
+                                    VkImageBlit2* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    reservedunmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource), ptr);
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        reservedunmarshal_VkOffset3D(vkStream, rootType,
+                                     (VkOffset3D*)(forUnmarshaling->srcOffsets + i), ptr);
+    }
+    reservedunmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource), ptr);
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        reservedunmarshal_VkOffset3D(vkStream, rootType,
+                                     (VkOffset3D*)(forUnmarshaling->dstOffsets + i), ptr);
+    }
+}
+
+void reservedunmarshal_VkBlitImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkBlitImageInfo2* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+    memcpy((VkImageLayout*)&forUnmarshaling->srcImageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    uint64_t cgen_var_1;
+    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
+    memcpy((VkImageLayout*)&forUnmarshaling->dstImageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkImageBlit2));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+        reservedunmarshal_VkImageBlit2(vkStream, rootType,
+                                       (VkImageBlit2*)(forUnmarshaling->pRegions + i), ptr);
+    }
+    memcpy((VkFilter*)&forUnmarshaling->filter, *ptr, sizeof(VkFilter));
+    *ptr += sizeof(VkFilter);
+}
+
+void reservedunmarshal_VkImageResolve2(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkImageResolve2* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    reservedunmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource), ptr);
+    reservedunmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset),
+                                 ptr);
+    reservedunmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource), ptr);
+    reservedunmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset),
+                                 ptr);
+    reservedunmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent), ptr);
+}
+
+void reservedunmarshal_VkResolveImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkResolveImageInfo2* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+    memcpy((VkImageLayout*)&forUnmarshaling->srcImageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    uint64_t cgen_var_1;
+    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
+    memcpy((VkImageLayout*)&forUnmarshaling->dstImageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkImageResolve2));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+        reservedunmarshal_VkImageResolve2(vkStream, rootType,
+                                          (VkImageResolve2*)(forUnmarshaling->pRegions + i), ptr);
+    }
+}
+
+void reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSubgroupSizeControlFeatures* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->subgroupSizeControl, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->computeFullSubgroups, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSubgroupSizeControlProperties* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->minSubgroupSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxSubgroupSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxComputeWorkgroupSubgroups, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((VkShaderStageFlags*)&forUnmarshaling->requiredSubgroupSizeStages, *ptr,
+           sizeof(VkShaderStageFlags));
+    *ptr += sizeof(VkShaderStageFlags);
+}
+
+void reservedunmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->requiredSubgroupSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkPhysicalDeviceInlineUniformBlockFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceInlineUniformBlockFeatures* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->inlineUniformBlock, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceInlineUniformBlockProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceInlineUniformBlockProperties* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->maxInlineUniformBlockSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInlineUniformBlocks, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
+           *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxDescriptorSetInlineUniformBlocks, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkWriteDescriptorSetInlineUniformBlock(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkWriteDescriptorSetInlineUniformBlock* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->dataSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pData,
+                    forUnmarshaling->dataSize * sizeof(const uint8_t));
+    memcpy((void*)forUnmarshaling->pData, *ptr, forUnmarshaling->dataSize * sizeof(const uint8_t));
+    *ptr += forUnmarshaling->dataSize * sizeof(const uint8_t);
+}
+
+void reservedunmarshal_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorPoolInlineUniformBlockCreateInfo* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->maxInlineUniformBlockBindings, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->textureCompressionASTC_HDR, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkRenderingAttachmentInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                                 VkRenderingAttachmentInfo* forUnmarshaling,
+                                                 uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImageView*)&forUnmarshaling->imageView =
+        (VkImageView)unbox_VkImageView((VkImageView)(*&cgen_var_0));
+    memcpy((VkImageLayout*)&forUnmarshaling->imageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    memcpy((VkResolveModeFlagBits*)&forUnmarshaling->resolveMode, *ptr,
+           sizeof(VkResolveModeFlagBits));
+    *ptr += sizeof(VkResolveModeFlagBits);
+    uint64_t cgen_var_1;
+    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImageView*)&forUnmarshaling->resolveImageView =
+        (VkImageView)unbox_VkImageView((VkImageView)(*&cgen_var_1));
+    memcpy((VkImageLayout*)&forUnmarshaling->resolveImageLayout, *ptr, sizeof(VkImageLayout));
+    *ptr += sizeof(VkImageLayout);
+    memcpy((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, *ptr, sizeof(VkAttachmentLoadOp));
+    *ptr += sizeof(VkAttachmentLoadOp);
+    memcpy((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, *ptr, sizeof(VkAttachmentStoreOp));
+    *ptr += sizeof(VkAttachmentStoreOp);
+    reservedunmarshal_VkClearValue(vkStream, rootType,
+                                   (VkClearValue*)(&forUnmarshaling->clearValue), ptr);
+}
+
+void reservedunmarshal_VkRenderingInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkRenderingInfo* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkRenderingFlags*)&forUnmarshaling->flags, *ptr, sizeof(VkRenderingFlags));
+    *ptr += sizeof(VkRenderingFlags);
+    reservedunmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->renderArea), ptr);
+    memcpy((uint32_t*)&forUnmarshaling->layerCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->viewMask, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->colorAttachmentCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pColorAttachments,
+        forUnmarshaling->colorAttachmentCount * sizeof(const VkRenderingAttachmentInfo));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
+        reservedunmarshal_VkRenderingAttachmentInfo(
+            vkStream, rootType,
+            (VkRenderingAttachmentInfo*)(forUnmarshaling->pColorAttachments + i), ptr);
+    }
+    // WARNING PTR CHECK
+    memcpy((VkRenderingAttachmentInfo**)&forUnmarshaling->pDepthAttachment, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pDepthAttachment);
+    *ptr += 8;
+    if (forUnmarshaling->pDepthAttachment) {
+        vkStream->alloc((void**)&forUnmarshaling->pDepthAttachment,
+                        sizeof(const VkRenderingAttachmentInfo));
+        reservedunmarshal_VkRenderingAttachmentInfo(
+            vkStream, rootType, (VkRenderingAttachmentInfo*)(forUnmarshaling->pDepthAttachment),
+            ptr);
+    }
+    // WARNING PTR CHECK
+    memcpy((VkRenderingAttachmentInfo**)&forUnmarshaling->pStencilAttachment, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pStencilAttachment);
+    *ptr += 8;
+    if (forUnmarshaling->pStencilAttachment) {
+        vkStream->alloc((void**)&forUnmarshaling->pStencilAttachment,
+                        sizeof(const VkRenderingAttachmentInfo));
+        reservedunmarshal_VkRenderingAttachmentInfo(
+            vkStream, rootType, (VkRenderingAttachmentInfo*)(forUnmarshaling->pStencilAttachment),
+            ptr);
+    }
+}
+
+void reservedunmarshal_VkPipelineRenderingCreateInfo(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkPipelineRenderingCreateInfo* forUnmarshaling,
+                                                     uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->viewMask, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->colorAttachmentCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    // WARNING PTR CHECK
+    memcpy((VkFormat**)&forUnmarshaling->pColorAttachmentFormats, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pColorAttachmentFormats);
+    *ptr += 8;
+    if (forUnmarshaling->pColorAttachmentFormats) {
+        vkStream->alloc((void**)&forUnmarshaling->pColorAttachmentFormats,
+                        forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+        memcpy((VkFormat*)forUnmarshaling->pColorAttachmentFormats, *ptr,
+               forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+        *ptr += forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat);
+    }
+    memcpy((VkFormat*)&forUnmarshaling->depthAttachmentFormat, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+    memcpy((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+}
+
+void reservedunmarshal_VkPhysicalDeviceDynamicRenderingFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDynamicRenderingFeatures* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->dynamicRendering, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkCommandBufferInheritanceRenderingInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkCommandBufferInheritanceRenderingInfo* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkRenderingFlags*)&forUnmarshaling->flags, *ptr, sizeof(VkRenderingFlags));
+    *ptr += sizeof(VkRenderingFlags);
+    memcpy((uint32_t*)&forUnmarshaling->viewMask, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->colorAttachmentCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pColorAttachmentFormats,
+                    forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+    memcpy((VkFormat*)forUnmarshaling->pColorAttachmentFormats, *ptr,
+           forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
+    *ptr += forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat);
+    memcpy((VkFormat*)&forUnmarshaling->depthAttachmentFormat, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+    memcpy((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+    memcpy((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples, *ptr,
+           sizeof(VkSampleCountFlagBits));
+    *ptr += sizeof(VkSampleCountFlagBits);
+}
+
+void reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderIntegerDotProductFeatures* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->shaderIntegerDotProduct, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderIntegerDotProductProperties* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct8BitUnsignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct8BitSignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct8BitMixedSignednessAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedSignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct16BitUnsignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct16BitSignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct16BitMixedSignednessAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct32BitUnsignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct32BitSignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct32BitMixedSignednessAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct64BitUnsignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct64BitSignedAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct64BitMixedSignednessAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
+        *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
+        *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
+        *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
+        *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy(
+        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
+        *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling
+               ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceTexelBufferAlignmentProperties* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkDeviceSize*)&forUnmarshaling->storageTexelBufferOffsetAlignmentBytes, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkBool32*)&forUnmarshaling->storageTexelBufferOffsetSingleTexelAlignment, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkDeviceSize*)&forUnmarshaling->uniformTexelBufferOffsetAlignmentBytes, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkBool32*)&forUnmarshaling->uniformTexelBufferOffsetSingleTexelAlignment, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkFormatProperties3(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkFormatProperties3* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkFormatFeatureFlags2*)&forUnmarshaling->linearTilingFeatures, *ptr,
+           sizeof(VkFormatFeatureFlags2));
+    *ptr += sizeof(VkFormatFeatureFlags2);
+    memcpy((VkFormatFeatureFlags2*)&forUnmarshaling->optimalTilingFeatures, *ptr,
+           sizeof(VkFormatFeatureFlags2));
+    *ptr += sizeof(VkFormatFeatureFlags2);
+    memcpy((VkFormatFeatureFlags2*)&forUnmarshaling->bufferFeatures, *ptr,
+           sizeof(VkFormatFeatureFlags2));
+    *ptr += sizeof(VkFormatFeatureFlags2);
+}
+
+void reservedunmarshal_VkPhysicalDeviceMaintenance4Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance4Features* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->maintenance4, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceMaintenance4Properties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance4Properties* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkDeviceSize*)&forUnmarshaling->maxBufferSize, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+}
+
+void reservedunmarshal_VkDeviceBufferMemoryRequirements(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceBufferMemoryRequirements* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pCreateInfo, sizeof(const VkBufferCreateInfo));
+    reservedunmarshal_VkBufferCreateInfo(vkStream, rootType,
+                                         (VkBufferCreateInfo*)(forUnmarshaling->pCreateInfo), ptr);
+}
+
+void reservedunmarshal_VkDeviceImageMemoryRequirements(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceImageMemoryRequirements* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pCreateInfo, sizeof(const VkImageCreateInfo));
+    reservedunmarshal_VkImageCreateInfo(vkStream, rootType,
+                                        (VkImageCreateInfo*)(forUnmarshaling->pCreateInfo), ptr);
+    memcpy((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect, *ptr,
+           sizeof(VkImageAspectFlagBits));
+    *ptr += sizeof(VkImageAspectFlagBits);
+}
+
+#endif
 #ifdef VK_KHR_surface
 void reservedunmarshal_VkSurfaceCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                                 VkSurfaceCapabilitiesKHR* forUnmarshaling,
@@ -8885,9 +11094,38 @@ void reservedunmarshal_VkWin32SurfaceCreateInfoKHR(VulkanStream* vkStream, VkStr
 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
 #endif
 #ifdef VK_KHR_video_queue
-void reservedunmarshal_VkVideoQueueFamilyProperties2KHR(
+void reservedunmarshal_VkQueueFamilyQueryResultStatusPropertiesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoQueueFamilyProperties2KHR* forUnmarshaling, uint8_t** ptr) {
+    VkQueueFamilyQueryResultStatusPropertiesKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->queryResultStatusSupport, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkQueueFamilyVideoPropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkQueueFamilyVideoPropertiesKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -8915,8 +11153,9 @@ void reservedunmarshal_VkVideoQueueFamilyProperties2KHR(
     *ptr += sizeof(VkVideoCodecOperationFlagsKHR);
 }
 
-void reservedunmarshal_VkVideoProfileKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                         VkVideoProfileKHR* forUnmarshaling, uint8_t** ptr) {
+void reservedunmarshal_VkVideoProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkVideoProfileInfoKHR* forUnmarshaling,
+                                             uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -8953,8 +11192,9 @@ void reservedunmarshal_VkVideoProfileKHR(VulkanStream* vkStream, VkStructureType
     *ptr += sizeof(VkVideoComponentBitDepthFlagsKHR);
 }
 
-void reservedunmarshal_VkVideoProfilesKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                          VkVideoProfilesKHR* forUnmarshaling, uint8_t** ptr) {
+void reservedunmarshal_VkVideoProfileListInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                 VkVideoProfileListInfoKHR* forUnmarshaling,
+                                                 uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -8979,9 +11219,12 @@ void reservedunmarshal_VkVideoProfilesKHR(VulkanStream* vkStream, VkStructureTyp
     }
     memcpy((uint32_t*)&forUnmarshaling->profileCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pProfiles, sizeof(const VkVideoProfileKHR));
-    reservedunmarshal_VkVideoProfileKHR(vkStream, rootType,
-                                        (VkVideoProfileKHR*)(forUnmarshaling->pProfiles), ptr);
+    vkStream->alloc((void**)&forUnmarshaling->pProfiles,
+                    forUnmarshaling->profileCount * sizeof(const VkVideoProfileInfoKHR));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->profileCount; ++i) {
+        reservedunmarshal_VkVideoProfileInfoKHR(
+            vkStream, rootType, (VkVideoProfileInfoKHR*)(forUnmarshaling->pProfiles + i), ptr);
+    }
 }
 
 void reservedunmarshal_VkVideoCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
@@ -9009,7 +11252,7 @@ void reservedunmarshal_VkVideoCapabilitiesKHR(VulkanStream* vkStream, VkStructur
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkVideoCapabilityFlagsKHR*)&forUnmarshaling->capabilityFlags, *ptr,
+    memcpy((VkVideoCapabilityFlagsKHR*)&forUnmarshaling->flags, *ptr,
            sizeof(VkVideoCapabilityFlagsKHR));
     *ptr += sizeof(VkVideoCapabilityFlagsKHR);
     memcpy((VkDeviceSize*)&forUnmarshaling->minBitstreamBufferOffsetAlignment, *ptr,
@@ -9018,16 +11261,18 @@ void reservedunmarshal_VkVideoCapabilitiesKHR(VulkanStream* vkStream, VkStructur
     memcpy((VkDeviceSize*)&forUnmarshaling->minBitstreamBufferSizeAlignment, *ptr,
            sizeof(VkDeviceSize));
     *ptr += sizeof(VkDeviceSize);
-    reservedunmarshal_VkExtent2D(
-        vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->videoPictureExtentGranularity), ptr);
-    reservedunmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->minExtent),
-                                 ptr);
-    reservedunmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->maxExtent),
-                                 ptr);
-    memcpy((uint32_t*)&forUnmarshaling->maxReferencePicturesSlotsCount, *ptr, sizeof(uint32_t));
+    reservedunmarshal_VkExtent2D(vkStream, rootType,
+                                 (VkExtent2D*)(&forUnmarshaling->pictureAccessGranularity), ptr);
+    reservedunmarshal_VkExtent2D(vkStream, rootType,
+                                 (VkExtent2D*)(&forUnmarshaling->minCodedExtent), ptr);
+    reservedunmarshal_VkExtent2D(vkStream, rootType,
+                                 (VkExtent2D*)(&forUnmarshaling->maxCodedExtent), ptr);
+    memcpy((uint32_t*)&forUnmarshaling->maxDpbSlots, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->maxReferencePicturesActiveCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->maxActiveReferencePictures, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
+    reservedunmarshal_VkExtensionProperties(
+        vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdHeaderVersion), ptr);
 }
 
 void reservedunmarshal_VkPhysicalDeviceVideoFormatInfoKHR(
@@ -9057,9 +11302,6 @@ void reservedunmarshal_VkPhysicalDeviceVideoFormatInfoKHR(
     }
     memcpy((VkImageUsageFlags*)&forUnmarshaling->imageUsage, *ptr, sizeof(VkImageUsageFlags));
     *ptr += sizeof(VkImageUsageFlags);
-    vkStream->alloc((void**)&forUnmarshaling->pVideoProfiles, sizeof(const VkVideoProfilesKHR));
-    reservedunmarshal_VkVideoProfilesKHR(
-        vkStream, rootType, (VkVideoProfilesKHR*)(forUnmarshaling->pVideoProfiles), ptr);
 }
 
 void reservedunmarshal_VkVideoFormatPropertiesKHR(VulkanStream* vkStream, VkStructureType rootType,
@@ -9089,11 +11331,23 @@ void reservedunmarshal_VkVideoFormatPropertiesKHR(VulkanStream* vkStream, VkStru
     }
     memcpy((VkFormat*)&forUnmarshaling->format, *ptr, sizeof(VkFormat));
     *ptr += sizeof(VkFormat);
+    reservedunmarshal_VkComponentMapping(
+        vkStream, rootType, (VkComponentMapping*)(&forUnmarshaling->componentMapping), ptr);
+    memcpy((VkImageCreateFlags*)&forUnmarshaling->imageCreateFlags, *ptr,
+           sizeof(VkImageCreateFlags));
+    *ptr += sizeof(VkImageCreateFlags);
+    memcpy((VkImageType*)&forUnmarshaling->imageType, *ptr, sizeof(VkImageType));
+    *ptr += sizeof(VkImageType);
+    memcpy((VkImageTiling*)&forUnmarshaling->imageTiling, *ptr, sizeof(VkImageTiling));
+    *ptr += sizeof(VkImageTiling);
+    memcpy((VkImageUsageFlags*)&forUnmarshaling->imageUsageFlags, *ptr, sizeof(VkImageUsageFlags));
+    *ptr += sizeof(VkImageUsageFlags);
 }
 
-void reservedunmarshal_VkVideoPictureResourceKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                 VkVideoPictureResourceKHR* forUnmarshaling,
-                                                 uint8_t** ptr) {
+void reservedunmarshal_VkVideoPictureResourceInfoKHR(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkVideoPictureResourceInfoKHR* forUnmarshaling,
+                                                     uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -9129,9 +11383,9 @@ void reservedunmarshal_VkVideoPictureResourceKHR(VulkanStream* vkStream, VkStruc
         (VkImageView)unbox_VkImageView((VkImageView)(*&cgen_var_0));
 }
 
-void reservedunmarshal_VkVideoReferenceSlotKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoReferenceSlotKHR* forUnmarshaling,
-                                               uint8_t** ptr) {
+void reservedunmarshal_VkVideoReferenceSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkVideoReferenceSlotInfoKHR* forUnmarshaling,
+                                                   uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -9154,18 +11408,24 @@ void reservedunmarshal_VkVideoReferenceSlotKHR(VulkanStream* vkStream, VkStructu
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((int8_t*)&forUnmarshaling->slotIndex, *ptr, sizeof(int8_t));
-    *ptr += sizeof(int8_t);
-    vkStream->alloc((void**)&forUnmarshaling->pPictureResource,
-                    sizeof(const VkVideoPictureResourceKHR));
-    reservedunmarshal_VkVideoPictureResourceKHR(
-        vkStream, rootType, (VkVideoPictureResourceKHR*)(forUnmarshaling->pPictureResource), ptr);
+    memcpy((int32_t*)&forUnmarshaling->slotIndex, *ptr, sizeof(int32_t));
+    *ptr += sizeof(int32_t);
+    // WARNING PTR CHECK
+    memcpy((VkVideoPictureResourceInfoKHR**)&forUnmarshaling->pPictureResource, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pPictureResource);
+    *ptr += 8;
+    if (forUnmarshaling->pPictureResource) {
+        vkStream->alloc((void**)&forUnmarshaling->pPictureResource,
+                        sizeof(const VkVideoPictureResourceInfoKHR));
+        reservedunmarshal_VkVideoPictureResourceInfoKHR(
+            vkStream, rootType, (VkVideoPictureResourceInfoKHR*)(forUnmarshaling->pPictureResource),
+            ptr);
+    }
 }
 
-void reservedunmarshal_VkVideoGetMemoryPropertiesKHR(VulkanStream* vkStream,
-                                                     VkStructureType rootType,
-                                                     VkVideoGetMemoryPropertiesKHR* forUnmarshaling,
-                                                     uint8_t** ptr) {
+void reservedunmarshal_VkVideoSessionMemoryRequirementsKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoSessionMemoryRequirementsKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -9190,13 +11450,13 @@ void reservedunmarshal_VkVideoGetMemoryPropertiesKHR(VulkanStream* vkStream,
     }
     memcpy((uint32_t*)&forUnmarshaling->memoryBindIndex, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pMemoryRequirements, sizeof(VkMemoryRequirements2));
-    reservedunmarshal_VkMemoryRequirements2(
-        vkStream, rootType, (VkMemoryRequirements2*)(forUnmarshaling->pMemoryRequirements), ptr);
+    reservedunmarshal_VkMemoryRequirements(
+        vkStream, rootType, (VkMemoryRequirements*)(&forUnmarshaling->memoryRequirements), ptr);
 }
 
-void reservedunmarshal_VkVideoBindMemoryKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                            VkVideoBindMemoryKHR* forUnmarshaling, uint8_t** ptr) {
+void reservedunmarshal_VkBindVideoSessionMemoryInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkBindVideoSessionMemoryInfoKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -9262,19 +11522,23 @@ void reservedunmarshal_VkVideoSessionCreateInfoKHR(VulkanStream* vkStream, VkStr
     memcpy((VkVideoSessionCreateFlagsKHR*)&forUnmarshaling->flags, *ptr,
            sizeof(VkVideoSessionCreateFlagsKHR));
     *ptr += sizeof(VkVideoSessionCreateFlagsKHR);
-    vkStream->alloc((void**)&forUnmarshaling->pVideoProfile, sizeof(const VkVideoProfileKHR));
-    reservedunmarshal_VkVideoProfileKHR(vkStream, rootType,
-                                        (VkVideoProfileKHR*)(forUnmarshaling->pVideoProfile), ptr);
+    vkStream->alloc((void**)&forUnmarshaling->pVideoProfile, sizeof(const VkVideoProfileInfoKHR));
+    reservedunmarshal_VkVideoProfileInfoKHR(
+        vkStream, rootType, (VkVideoProfileInfoKHR*)(forUnmarshaling->pVideoProfile), ptr);
     memcpy((VkFormat*)&forUnmarshaling->pictureFormat, *ptr, sizeof(VkFormat));
     *ptr += sizeof(VkFormat);
     reservedunmarshal_VkExtent2D(vkStream, rootType,
                                  (VkExtent2D*)(&forUnmarshaling->maxCodedExtent), ptr);
-    memcpy((VkFormat*)&forUnmarshaling->referencePicturesFormat, *ptr, sizeof(VkFormat));
+    memcpy((VkFormat*)&forUnmarshaling->referencePictureFormat, *ptr, sizeof(VkFormat));
     *ptr += sizeof(VkFormat);
-    memcpy((uint32_t*)&forUnmarshaling->maxReferencePicturesSlotsCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->maxDpbSlots, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->maxReferencePicturesActiveCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->maxActiveReferencePictures, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pStdHeaderVersion,
+                    sizeof(const VkExtensionProperties));
+    reservedunmarshal_VkExtensionProperties(
+        vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdHeaderVersion), ptr);
 }
 
 void reservedunmarshal_VkVideoSessionParametersCreateInfoKHR(
@@ -9302,6 +11566,9 @@ void reservedunmarshal_VkVideoSessionParametersCreateInfoKHR(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
+    memcpy((VkVideoSessionParametersCreateFlagsKHR*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkVideoSessionParametersCreateFlagsKHR));
+    *ptr += sizeof(VkVideoSessionParametersCreateFlagsKHR);
     memcpy((VkVideoSessionParametersKHR*)&forUnmarshaling->videoSessionParametersTemplate, (*ptr),
            8);
     android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->videoSessionParametersTemplate);
@@ -9368,9 +11635,6 @@ void reservedunmarshal_VkVideoBeginCodingInfoKHR(VulkanStream* vkStream, VkStruc
     memcpy((VkVideoBeginCodingFlagsKHR*)&forUnmarshaling->flags, *ptr,
            sizeof(VkVideoBeginCodingFlagsKHR));
     *ptr += sizeof(VkVideoBeginCodingFlagsKHR);
-    memcpy((VkVideoCodingQualityPresetFlagsKHR*)&forUnmarshaling->codecQualityPreset, *ptr,
-           sizeof(VkVideoCodingQualityPresetFlagsKHR));
-    *ptr += sizeof(VkVideoCodingQualityPresetFlagsKHR);
     memcpy((VkVideoSessionKHR*)&forUnmarshaling->videoSession, (*ptr), 8);
     android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->videoSession);
     *ptr += 8;
@@ -9379,12 +11643,13 @@ void reservedunmarshal_VkVideoBeginCodingInfoKHR(VulkanStream* vkStream, VkStruc
     *ptr += 8;
     memcpy((uint32_t*)&forUnmarshaling->referenceSlotCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pReferenceSlots,
-                    forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pReferenceSlots,
+        forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotInfoKHR));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i) {
-        reservedunmarshal_VkVideoReferenceSlotKHR(
-            vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pReferenceSlots + i),
-            ptr);
+        reservedunmarshal_VkVideoReferenceSlotInfoKHR(
+            vkStream, rootType,
+            (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pReferenceSlots + i), ptr);
     }
 }
 
@@ -9450,6 +11715,67 @@ void reservedunmarshal_VkVideoCodingControlInfoKHR(VulkanStream* vkStream, VkStr
 
 #endif
 #ifdef VK_KHR_video_decode_queue
+void reservedunmarshal_VkVideoDecodeCapabilitiesKHR(VulkanStream* vkStream,
+                                                    VkStructureType rootType,
+                                                    VkVideoDecodeCapabilitiesKHR* forUnmarshaling,
+                                                    uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkVideoDecodeCapabilityFlagsKHR*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkVideoDecodeCapabilityFlagsKHR));
+    *ptr += sizeof(VkVideoDecodeCapabilityFlagsKHR);
+}
+
+void reservedunmarshal_VkVideoDecodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                 VkVideoDecodeUsageInfoKHR* forUnmarshaling,
+                                                 uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkVideoDecodeUsageFlagsKHR*)&forUnmarshaling->videoUsageHints, *ptr,
+           sizeof(VkVideoDecodeUsageFlagsKHR));
+    *ptr += sizeof(VkVideoDecodeUsageFlagsKHR);
+}
+
 void reservedunmarshal_VkVideoDecodeInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkVideoDecodeInfoKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
@@ -9476,10 +11802,6 @@ void reservedunmarshal_VkVideoDecodeInfoKHR(VulkanStream* vkStream, VkStructureT
     }
     memcpy((VkVideoDecodeFlagsKHR*)&forUnmarshaling->flags, *ptr, sizeof(VkVideoDecodeFlagsKHR));
     *ptr += sizeof(VkVideoDecodeFlagsKHR);
-    reservedunmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->codedOffset),
-                                 ptr);
-    reservedunmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->codedExtent),
-                                 ptr);
     uint64_t cgen_var_0;
     memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
     *ptr += 1 * 8;
@@ -9488,30 +11810,31 @@ void reservedunmarshal_VkVideoDecodeInfoKHR(VulkanStream* vkStream, VkStructureT
     *ptr += sizeof(VkDeviceSize);
     memcpy((VkDeviceSize*)&forUnmarshaling->srcBufferRange, *ptr, sizeof(VkDeviceSize));
     *ptr += sizeof(VkDeviceSize);
-    reservedunmarshal_VkVideoPictureResourceKHR(
-        vkStream, rootType, (VkVideoPictureResourceKHR*)(&forUnmarshaling->dstPictureResource),
+    reservedunmarshal_VkVideoPictureResourceInfoKHR(
+        vkStream, rootType, (VkVideoPictureResourceInfoKHR*)(&forUnmarshaling->dstPictureResource),
         ptr);
     vkStream->alloc((void**)&forUnmarshaling->pSetupReferenceSlot,
-                    sizeof(const VkVideoReferenceSlotKHR));
-    reservedunmarshal_VkVideoReferenceSlotKHR(
-        vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pSetupReferenceSlot), ptr);
+                    sizeof(const VkVideoReferenceSlotInfoKHR));
+    reservedunmarshal_VkVideoReferenceSlotInfoKHR(
+        vkStream, rootType, (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pSetupReferenceSlot),
+        ptr);
     memcpy((uint32_t*)&forUnmarshaling->referenceSlotCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pReferenceSlots,
-                    forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pReferenceSlots,
+        forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotInfoKHR));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i) {
-        reservedunmarshal_VkVideoReferenceSlotKHR(
-            vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pReferenceSlots + i),
-            ptr);
+        reservedunmarshal_VkVideoReferenceSlotInfoKHR(
+            vkStream, rootType,
+            (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pReferenceSlots + i), ptr);
     }
 }
 
 #endif
-#ifdef VK_KHR_dynamic_rendering
-void reservedunmarshal_VkRenderingAttachmentInfoKHR(VulkanStream* vkStream,
-                                                    VkStructureType rootType,
-                                                    VkRenderingAttachmentInfoKHR* forUnmarshaling,
-                                                    uint8_t** ptr) {
+#ifdef VK_KHR_video_decode_h264
+void reservedunmarshal_VkVideoDecodeH264ProfileInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH264ProfileInfoKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -9534,33 +11857,17 @@ void reservedunmarshal_VkRenderingAttachmentInfoKHR(VulkanStream* vkStream,
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    uint64_t cgen_var_0;
-    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkImageView*)&forUnmarshaling->imageView =
-        (VkImageView)unbox_VkImageView((VkImageView)(*&cgen_var_0));
-    memcpy((VkImageLayout*)&forUnmarshaling->imageLayout, *ptr, sizeof(VkImageLayout));
-    *ptr += sizeof(VkImageLayout);
-    memcpy((VkResolveModeFlagBits*)&forUnmarshaling->resolveMode, *ptr,
-           sizeof(VkResolveModeFlagBits));
-    *ptr += sizeof(VkResolveModeFlagBits);
-    uint64_t cgen_var_1;
-    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkImageView*)&forUnmarshaling->resolveImageView =
-        (VkImageView)unbox_VkImageView((VkImageView)(*&cgen_var_1));
-    memcpy((VkImageLayout*)&forUnmarshaling->resolveImageLayout, *ptr, sizeof(VkImageLayout));
-    *ptr += sizeof(VkImageLayout);
-    memcpy((VkAttachmentLoadOp*)&forUnmarshaling->loadOp, *ptr, sizeof(VkAttachmentLoadOp));
-    *ptr += sizeof(VkAttachmentLoadOp);
-    memcpy((VkAttachmentStoreOp*)&forUnmarshaling->storeOp, *ptr, sizeof(VkAttachmentStoreOp));
-    *ptr += sizeof(VkAttachmentStoreOp);
-    reservedunmarshal_VkClearValue(vkStream, rootType,
-                                   (VkClearValue*)(&forUnmarshaling->clearValue), ptr);
+    memcpy((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc, *ptr,
+           sizeof(StdVideoH264ProfileIdc));
+    *ptr += sizeof(StdVideoH264ProfileIdc);
+    memcpy((VkVideoDecodeH264PictureLayoutFlagBitsKHR*)&forUnmarshaling->pictureLayout, *ptr,
+           sizeof(VkVideoDecodeH264PictureLayoutFlagBitsKHR));
+    *ptr += sizeof(VkVideoDecodeH264PictureLayoutFlagBitsKHR);
 }
 
-void reservedunmarshal_VkRenderingInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                          VkRenderingInfoKHR* forUnmarshaling, uint8_t** ptr) {
+void reservedunmarshal_VkVideoDecodeH264CapabilitiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH264CapabilitiesKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -9583,50 +11890,57 @@ void reservedunmarshal_VkRenderingInfoKHR(VulkanStream* vkStream, VkStructureTyp
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkRenderingFlagsKHR*)&forUnmarshaling->flags, *ptr, sizeof(VkRenderingFlagsKHR));
-    *ptr += sizeof(VkRenderingFlagsKHR);
-    reservedunmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(&forUnmarshaling->renderArea), ptr);
-    memcpy((uint32_t*)&forUnmarshaling->layerCount, *ptr, sizeof(uint32_t));
+    memcpy((StdVideoH264LevelIdc*)&forUnmarshaling->maxLevelIdc, *ptr,
+           sizeof(StdVideoH264LevelIdc));
+    *ptr += sizeof(StdVideoH264LevelIdc);
+    reservedunmarshal_VkOffset2D(vkStream, rootType,
+                                 (VkOffset2D*)(&forUnmarshaling->fieldOffsetGranularity), ptr);
+}
+
+void reservedunmarshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH264SessionParametersAddInfoKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
     *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->viewMask, *ptr, sizeof(uint32_t));
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->stdSPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->colorAttachmentCount, *ptr, sizeof(uint32_t));
+    vkStream->alloc((void**)&forUnmarshaling->pStdSPSs,
+                    forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
+    memcpy((StdVideoH264SequenceParameterSet*)forUnmarshaling->pStdSPSs, *ptr,
+           forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
+    *ptr += forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet);
+    memcpy((uint32_t*)&forUnmarshaling->stdPPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pColorAttachments,
-        forUnmarshaling->colorAttachmentCount * sizeof(const VkRenderingAttachmentInfoKHR));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorAttachmentCount; ++i) {
-        reservedunmarshal_VkRenderingAttachmentInfoKHR(
-            vkStream, rootType,
-            (VkRenderingAttachmentInfoKHR*)(forUnmarshaling->pColorAttachments + i), ptr);
-    }
-    // WARNING PTR CHECK
-    memcpy((VkRenderingAttachmentInfoKHR**)&forUnmarshaling->pDepthAttachment, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pDepthAttachment);
-    *ptr += 8;
-    if (forUnmarshaling->pDepthAttachment) {
-        vkStream->alloc((void**)&forUnmarshaling->pDepthAttachment,
-                        sizeof(const VkRenderingAttachmentInfoKHR));
-        reservedunmarshal_VkRenderingAttachmentInfoKHR(
-            vkStream, rootType, (VkRenderingAttachmentInfoKHR*)(forUnmarshaling->pDepthAttachment),
-            ptr);
-    }
-    // WARNING PTR CHECK
-    memcpy((VkRenderingAttachmentInfoKHR**)&forUnmarshaling->pStencilAttachment, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pStencilAttachment);
-    *ptr += 8;
-    if (forUnmarshaling->pStencilAttachment) {
-        vkStream->alloc((void**)&forUnmarshaling->pStencilAttachment,
-                        sizeof(const VkRenderingAttachmentInfoKHR));
-        reservedunmarshal_VkRenderingAttachmentInfoKHR(
-            vkStream, rootType,
-            (VkRenderingAttachmentInfoKHR*)(forUnmarshaling->pStencilAttachment), ptr);
-    }
+    vkStream->alloc((void**)&forUnmarshaling->pStdPPSs,
+                    forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
+    memcpy((StdVideoH264PictureParameterSet*)forUnmarshaling->pStdPPSs, *ptr,
+           forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
+    *ptr += forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet);
 }
 
-void reservedunmarshal_VkPipelineRenderingCreateInfoKHR(
+void reservedunmarshal_VkVideoDecodeH264SessionParametersCreateInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPipelineRenderingCreateInfoKHR* forUnmarshaling, uint8_t** ptr) {
+    VkVideoDecodeH264SessionParametersCreateInfoKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -9649,24 +11963,28 @@ void reservedunmarshal_VkPipelineRenderingCreateInfoKHR(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((uint32_t*)&forUnmarshaling->viewMask, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->maxStdSPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->colorAttachmentCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->maxStdPPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pColorAttachmentFormats,
-                    forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
-    memcpy((VkFormat*)forUnmarshaling->pColorAttachmentFormats, *ptr,
-           forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
-    *ptr += forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat);
-    memcpy((VkFormat*)&forUnmarshaling->depthAttachmentFormat, *ptr, sizeof(VkFormat));
-    *ptr += sizeof(VkFormat);
-    memcpy((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, *ptr, sizeof(VkFormat));
-    *ptr += sizeof(VkFormat);
+    // WARNING PTR CHECK
+    memcpy((VkVideoDecodeH264SessionParametersAddInfoKHR**)&forUnmarshaling->pParametersAddInfo,
+           (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pParametersAddInfo);
+    *ptr += 8;
+    if (forUnmarshaling->pParametersAddInfo) {
+        vkStream->alloc((void**)&forUnmarshaling->pParametersAddInfo,
+                        sizeof(const VkVideoDecodeH264SessionParametersAddInfoKHR));
+        reservedunmarshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
+            vkStream, rootType,
+            (VkVideoDecodeH264SessionParametersAddInfoKHR*)(forUnmarshaling->pParametersAddInfo),
+            ptr);
+    }
 }
 
-void reservedunmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+void reservedunmarshal_VkVideoDecodeH264PictureInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceDynamicRenderingFeaturesKHR* forUnmarshaling, uint8_t** ptr) {
+    VkVideoDecodeH264PictureInfoKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -9689,13 +12007,23 @@ void reservedunmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->dynamicRendering, *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
+    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
+                    sizeof(const StdVideoDecodeH264PictureInfo));
+    memcpy((StdVideoDecodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo, *ptr,
+           sizeof(const StdVideoDecodeH264PictureInfo));
+    *ptr += sizeof(const StdVideoDecodeH264PictureInfo);
+    memcpy((uint32_t*)&forUnmarshaling->sliceCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pSliceOffsets,
+                    forUnmarshaling->sliceCount * sizeof(const uint32_t));
+    memcpy((uint32_t*)forUnmarshaling->pSliceOffsets, *ptr,
+           forUnmarshaling->sliceCount * sizeof(const uint32_t));
+    *ptr += forUnmarshaling->sliceCount * sizeof(const uint32_t);
 }
 
-void reservedunmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
+void reservedunmarshal_VkVideoDecodeH264DpbSlotInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkCommandBufferInheritanceRenderingInfoKHR* forUnmarshaling, uint8_t** ptr) {
+    VkVideoDecodeH264DpbSlotInfoKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -9718,26 +12046,15 @@ void reservedunmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkRenderingFlagsKHR*)&forUnmarshaling->flags, *ptr, sizeof(VkRenderingFlagsKHR));
-    *ptr += sizeof(VkRenderingFlagsKHR);
-    memcpy((uint32_t*)&forUnmarshaling->viewMask, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->colorAttachmentCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pColorAttachmentFormats,
-                    forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
-    memcpy((VkFormat*)forUnmarshaling->pColorAttachmentFormats, *ptr,
-           forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat));
-    *ptr += forUnmarshaling->colorAttachmentCount * sizeof(const VkFormat);
-    memcpy((VkFormat*)&forUnmarshaling->depthAttachmentFormat, *ptr, sizeof(VkFormat));
-    *ptr += sizeof(VkFormat);
-    memcpy((VkFormat*)&forUnmarshaling->stencilAttachmentFormat, *ptr, sizeof(VkFormat));
-    *ptr += sizeof(VkFormat);
-    memcpy((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples, *ptr,
-           sizeof(VkSampleCountFlagBits));
-    *ptr += sizeof(VkSampleCountFlagBits);
+    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
+                    sizeof(const StdVideoDecodeH264ReferenceInfo));
+    memcpy((StdVideoDecodeH264ReferenceInfo*)forUnmarshaling->pStdReferenceInfo, *ptr,
+           sizeof(const StdVideoDecodeH264ReferenceInfo));
+    *ptr += sizeof(const StdVideoDecodeH264ReferenceInfo);
 }
 
+#endif
+#ifdef VK_KHR_dynamic_rendering
 void reservedunmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
     VkRenderingFragmentShadingRateAttachmentInfoKHR* forUnmarshaling, uint8_t** ptr) {
@@ -11444,22 +13761,237 @@ void reservedunmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
 }
 
 #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
+#ifdef VK_KHR_video_decode_h265
+void reservedunmarshal_VkVideoDecodeH265ProfileInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265ProfileInfoKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((StdVideoH265ProfileIdc*)&forUnmarshaling->stdProfileIdc, *ptr,
+           sizeof(StdVideoH265ProfileIdc));
+    *ptr += sizeof(StdVideoH265ProfileIdc);
+}
+
+void reservedunmarshal_VkVideoDecodeH265CapabilitiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265CapabilitiesKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((StdVideoH265LevelIdc*)&forUnmarshaling->maxLevelIdc, *ptr,
+           sizeof(StdVideoH265LevelIdc));
+    *ptr += sizeof(StdVideoH265LevelIdc);
+}
+
+void reservedunmarshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265SessionParametersAddInfoKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->stdVPSCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pStdVPSs,
+                    forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
+    memcpy((StdVideoH265VideoParameterSet*)forUnmarshaling->pStdVPSs, *ptr,
+           forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
+    *ptr += forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet);
+    memcpy((uint32_t*)&forUnmarshaling->stdSPSCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pStdSPSs,
+                    forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
+    memcpy((StdVideoH265SequenceParameterSet*)forUnmarshaling->pStdSPSs, *ptr,
+           forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
+    *ptr += forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet);
+    memcpy((uint32_t*)&forUnmarshaling->stdPPSCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pStdPPSs,
+                    forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
+    memcpy((StdVideoH265PictureParameterSet*)forUnmarshaling->pStdPPSs, *ptr,
+           forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
+    *ptr += forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet);
+}
+
+void reservedunmarshal_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265SessionParametersCreateInfoKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->maxStdVPSCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxStdSPSCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxStdPPSCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    // WARNING PTR CHECK
+    memcpy((VkVideoDecodeH265SessionParametersAddInfoKHR**)&forUnmarshaling->pParametersAddInfo,
+           (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pParametersAddInfo);
+    *ptr += 8;
+    if (forUnmarshaling->pParametersAddInfo) {
+        vkStream->alloc((void**)&forUnmarshaling->pParametersAddInfo,
+                        sizeof(const VkVideoDecodeH265SessionParametersAddInfoKHR));
+        reservedunmarshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
+            vkStream, rootType,
+            (VkVideoDecodeH265SessionParametersAddInfoKHR*)(forUnmarshaling->pParametersAddInfo),
+            ptr);
+    }
+}
+
+void reservedunmarshal_VkVideoDecodeH265PictureInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265PictureInfoKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
+                    sizeof(const StdVideoDecodeH265PictureInfo));
+    memcpy((StdVideoDecodeH265PictureInfo*)forUnmarshaling->pStdPictureInfo, *ptr,
+           sizeof(const StdVideoDecodeH265PictureInfo));
+    *ptr += sizeof(const StdVideoDecodeH265PictureInfo);
+    memcpy((uint32_t*)&forUnmarshaling->sliceSegmentCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pSliceSegmentOffsets,
+                    forUnmarshaling->sliceSegmentCount * sizeof(const uint32_t));
+    memcpy((uint32_t*)forUnmarshaling->pSliceSegmentOffsets, *ptr,
+           forUnmarshaling->sliceSegmentCount * sizeof(const uint32_t));
+    *ptr += forUnmarshaling->sliceSegmentCount * sizeof(const uint32_t);
+}
+
+void reservedunmarshal_VkVideoDecodeH265DpbSlotInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265DpbSlotInfoKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
+                    sizeof(const StdVideoDecodeH265ReferenceInfo));
+    memcpy((StdVideoDecodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo, *ptr,
+           sizeof(const StdVideoDecodeH265ReferenceInfo));
+    *ptr += sizeof(const StdVideoDecodeH265ReferenceInfo);
+}
+
 #endif
-#ifdef VK_KHR_shader_terminate_invocation
-void reservedunmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+#ifdef VK_KHR_global_priority
+void reservedunmarshal_VkDeviceQueueGlobalPriorityCreateInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forUnmarshaling, uint8_t** ptr) {
+    VkDeviceQueueGlobalPriorityCreateInfoKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -11482,10 +14014,86 @@ void reservedunmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->shaderTerminateInvocation, *ptr, sizeof(VkBool32));
+    memcpy((VkQueueGlobalPriorityKHR*)&forUnmarshaling->globalPriority, *ptr,
+           sizeof(VkQueueGlobalPriorityKHR));
+    *ptr += sizeof(VkQueueGlobalPriorityKHR);
+}
+
+void reservedunmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->globalPriorityQuery, *ptr, sizeof(VkBool32));
     *ptr += sizeof(VkBool32);
 }
 
+void reservedunmarshal_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkQueueFamilyGlobalPriorityPropertiesKHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->priorityCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((VkQueueGlobalPriorityKHR*)forUnmarshaling->priorities, *ptr,
+           VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR));
+    *ptr += VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR);
+}
+
+#endif
+#ifdef VK_KHR_driver_properties
+#endif
+#ifdef VK_KHR_shader_float_controls
+#endif
+#ifdef VK_KHR_depth_stencil_resolve
+#endif
+#ifdef VK_KHR_swapchain_mutable_format
+#endif
+#ifdef VK_KHR_timeline_semaphore
+#endif
+#ifdef VK_KHR_vulkan_memory_model
+#endif
+#ifdef VK_KHR_shader_terminate_invocation
 #endif
 #ifdef VK_KHR_fragment_shading_rate
 void reservedunmarshal_VkFragmentShadingRateAttachmentInfoKHR(
@@ -11991,10 +14599,9 @@ void reservedunmarshal_VkPipelineExecutableInternalRepresentationKHR(
 }
 
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-void reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forUnmarshaling, uint8_t** ptr) {
+#ifdef VK_KHR_map_memory2
+void reservedunmarshal_VkMemoryMapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkMemoryMapInfoKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12017,13 +14624,21 @@ void reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->shaderIntegerDotProduct, *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
+    memcpy((VkMemoryMapFlags*)&forUnmarshaling->flags, *ptr, sizeof(VkMemoryMapFlags));
+    *ptr += sizeof(VkMemoryMapFlags);
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkDeviceMemory*)&forUnmarshaling->memory =
+        (VkDeviceMemory)unbox_VkDeviceMemory((VkDeviceMemory)(*&cgen_var_0));
+    memcpy((VkDeviceSize*)&forUnmarshaling->offset, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceSize*)&forUnmarshaling->size, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
 }
 
-void reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forUnmarshaling, uint8_t** ptr) {
+void reservedunmarshal_VkMemoryUnmapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                            VkMemoryUnmapInfoKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12046,114 +14661,18 @@ void reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct8BitUnsignedAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct8BitSignedAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct8BitMixedSignednessAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedUnsignedAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedSignedAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct4x8BitPackedMixedSignednessAccelerated,
-           *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct16BitUnsignedAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct16BitSignedAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct16BitMixedSignednessAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct32BitUnsignedAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct32BitSignedAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct32BitMixedSignednessAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct64BitUnsignedAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct64BitSignedAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->integerDotProduct64BitMixedSignednessAccelerated, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy(
-        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated,
-        *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy(
-        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating8BitSignedAccelerated,
-        *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling
-               ->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated,
-           *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling
-               ->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated,
-           *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling
-               ->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated,
-           *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling
-               ->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated,
-           *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling
-               ->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated,
-           *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy(
-        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating16BitSignedAccelerated,
-        *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling
-               ->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated,
-           *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling
-               ->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated,
-           *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy(
-        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating32BitSignedAccelerated,
-        *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling
-               ->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated,
-           *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling
-               ->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated,
-           *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy(
-        (VkBool32*)&forUnmarshaling->integerDotProductAccumulatingSaturating64BitSignedAccelerated,
-        *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling
-               ->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated,
-           *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
+    memcpy((VkMemoryUnmapFlagsKHR*)&forUnmarshaling->flags, *ptr, sizeof(VkMemoryUnmapFlagsKHR));
+    *ptr += sizeof(VkMemoryUnmapFlagsKHR);
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkDeviceMemory*)&forUnmarshaling->memory =
+        (VkDeviceMemory)unbox_VkDeviceMemory((VkDeviceMemory)(*&cgen_var_0));
 }
 
 #endif
+#ifdef VK_KHR_shader_integer_dot_product
+#endif
 #ifdef VK_KHR_pipeline_library
 void reservedunmarshal_VkPipelineLibraryCreateInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -12300,38 +14819,46 @@ void reservedunmarshal_VkVideoEncodeInfoKHR(VulkanStream* vkStream, VkStructureT
     *ptr += sizeof(VkVideoEncodeFlagsKHR);
     memcpy((uint32_t*)&forUnmarshaling->qualityLevel, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    reservedunmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->codedExtent),
-                                 ptr);
     uint64_t cgen_var_0;
     memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
     *ptr += 1 * 8;
-    *(VkBuffer*)&forUnmarshaling->dstBitstreamBuffer =
-        (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
-    memcpy((VkDeviceSize*)&forUnmarshaling->dstBitstreamBufferOffset, *ptr, sizeof(VkDeviceSize));
+    *(VkBuffer*)&forUnmarshaling->dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+    memcpy((VkDeviceSize*)&forUnmarshaling->dstBufferOffset, *ptr, sizeof(VkDeviceSize));
     *ptr += sizeof(VkDeviceSize);
-    memcpy((VkDeviceSize*)&forUnmarshaling->dstBitstreamBufferMaxRange, *ptr, sizeof(VkDeviceSize));
+    memcpy((VkDeviceSize*)&forUnmarshaling->dstBufferRange, *ptr, sizeof(VkDeviceSize));
     *ptr += sizeof(VkDeviceSize);
-    reservedunmarshal_VkVideoPictureResourceKHR(
-        vkStream, rootType, (VkVideoPictureResourceKHR*)(&forUnmarshaling->srcPictureResource),
+    reservedunmarshal_VkVideoPictureResourceInfoKHR(
+        vkStream, rootType, (VkVideoPictureResourceInfoKHR*)(&forUnmarshaling->srcPictureResource),
         ptr);
-    vkStream->alloc((void**)&forUnmarshaling->pSetupReferenceSlot,
-                    sizeof(const VkVideoReferenceSlotKHR));
-    reservedunmarshal_VkVideoReferenceSlotKHR(
-        vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pSetupReferenceSlot), ptr);
+    // WARNING PTR CHECK
+    memcpy((VkVideoReferenceSlotInfoKHR**)&forUnmarshaling->pSetupReferenceSlot, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pSetupReferenceSlot);
+    *ptr += 8;
+    if (forUnmarshaling->pSetupReferenceSlot) {
+        vkStream->alloc((void**)&forUnmarshaling->pSetupReferenceSlot,
+                        sizeof(const VkVideoReferenceSlotInfoKHR));
+        reservedunmarshal_VkVideoReferenceSlotInfoKHR(
+            vkStream, rootType,
+            (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pSetupReferenceSlot), ptr);
+    }
     memcpy((uint32_t*)&forUnmarshaling->referenceSlotCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pReferenceSlots,
-                    forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotKHR));
+    vkStream->alloc(
+        (void**)&forUnmarshaling->pReferenceSlots,
+        forUnmarshaling->referenceSlotCount * sizeof(const VkVideoReferenceSlotInfoKHR));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceSlotCount; ++i) {
-        reservedunmarshal_VkVideoReferenceSlotKHR(
-            vkStream, rootType, (VkVideoReferenceSlotKHR*)(forUnmarshaling->pReferenceSlots + i),
-            ptr);
+        reservedunmarshal_VkVideoReferenceSlotInfoKHR(
+            vkStream, rootType,
+            (VkVideoReferenceSlotInfoKHR*)(forUnmarshaling->pReferenceSlots + i), ptr);
     }
+    memcpy((uint32_t*)&forUnmarshaling->precedingExternallyEncodedBytes, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
 }
 
-void reservedunmarshal_VkVideoEncodeRateControlInfoKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeRateControlInfoKHR* forUnmarshaling, uint8_t** ptr) {
+void reservedunmarshal_VkVideoEncodeCapabilitiesKHR(VulkanStream* vkStream,
+                                                    VkStructureType rootType,
+                                                    VkVideoEncodeCapabilitiesKHR* forUnmarshaling,
+                                                    uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12354,28 +14881,26 @@ void reservedunmarshal_VkVideoEncodeRateControlInfoKHR(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkVideoEncodeRateControlFlagsKHR*)&forUnmarshaling->flags, *ptr,
-           sizeof(VkVideoEncodeRateControlFlagsKHR));
-    *ptr += sizeof(VkVideoEncodeRateControlFlagsKHR);
-    memcpy((VkVideoEncodeRateControlModeFlagBitsKHR*)&forUnmarshaling->rateControlMode, *ptr,
-           sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
-    *ptr += sizeof(VkVideoEncodeRateControlModeFlagBitsKHR);
-    memcpy((uint32_t*)&forUnmarshaling->averageBitrate, *ptr, sizeof(uint32_t));
+    memcpy((VkVideoEncodeCapabilityFlagsKHR*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkVideoEncodeCapabilityFlagsKHR));
+    *ptr += sizeof(VkVideoEncodeCapabilityFlagsKHR);
+    memcpy((VkVideoEncodeRateControlModeFlagsKHR*)&forUnmarshaling->rateControlModes, *ptr,
+           sizeof(VkVideoEncodeRateControlModeFlagsKHR));
+    *ptr += sizeof(VkVideoEncodeRateControlModeFlagsKHR);
+    memcpy((uint32_t*)&forUnmarshaling->maxRateControlLayers, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    memcpy((uint16_t*)&forUnmarshaling->peakToAverageBitrateRatio, *ptr, sizeof(uint16_t));
-    *ptr += sizeof(uint16_t);
-    memcpy((uint16_t*)&forUnmarshaling->frameRateNumerator, *ptr, sizeof(uint16_t));
-    *ptr += sizeof(uint16_t);
-    memcpy((uint16_t*)&forUnmarshaling->frameRateDenominator, *ptr, sizeof(uint16_t));
-    *ptr += sizeof(uint16_t);
-    memcpy((uint32_t*)&forUnmarshaling->virtualBufferSizeInMs, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->maxQualityLevels, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
+    reservedunmarshal_VkExtent2D(vkStream, rootType,
+                                 (VkExtent2D*)(&forUnmarshaling->inputImageDataFillAlignment), ptr);
+    memcpy((VkVideoEncodeFeedbackFlagsKHR*)&forUnmarshaling->supportedEncodeFeedbackFlags, *ptr,
+           sizeof(VkVideoEncodeFeedbackFlagsKHR));
+    *ptr += sizeof(VkVideoEncodeFeedbackFlagsKHR);
 }
 
-#endif
-#ifdef VK_KHR_synchronization2
-void reservedunmarshal_VkMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkMemoryBarrier2KHR* forUnmarshaling, uint8_t** ptr) {
+void reservedunmarshal_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12398,20 +14923,13 @@ void reservedunmarshal_VkMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureTy
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkPipelineStageFlags2KHR*)&forUnmarshaling->srcStageMask, *ptr,
-           sizeof(VkPipelineStageFlags2KHR));
-    *ptr += sizeof(VkPipelineStageFlags2KHR);
-    memcpy((VkAccessFlags2KHR*)&forUnmarshaling->srcAccessMask, *ptr, sizeof(VkAccessFlags2KHR));
-    *ptr += sizeof(VkAccessFlags2KHR);
-    memcpy((VkPipelineStageFlags2KHR*)&forUnmarshaling->dstStageMask, *ptr,
-           sizeof(VkPipelineStageFlags2KHR));
-    *ptr += sizeof(VkPipelineStageFlags2KHR);
-    memcpy((VkAccessFlags2KHR*)&forUnmarshaling->dstAccessMask, *ptr, sizeof(VkAccessFlags2KHR));
-    *ptr += sizeof(VkAccessFlags2KHR);
+    memcpy((VkVideoEncodeFeedbackFlagsKHR*)&forUnmarshaling->encodeFeedbackFlags, *ptr,
+           sizeof(VkVideoEncodeFeedbackFlagsKHR));
+    *ptr += sizeof(VkVideoEncodeFeedbackFlagsKHR);
 }
 
-void reservedunmarshal_VkBufferMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                 VkBufferMemoryBarrier2KHR* forUnmarshaling,
+void reservedunmarshal_VkVideoEncodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                 VkVideoEncodeUsageInfoKHR* forUnmarshaling,
                                                  uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
@@ -12435,33 +14953,20 @@ void reservedunmarshal_VkBufferMemoryBarrier2KHR(VulkanStream* vkStream, VkStruc
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkPipelineStageFlags2KHR*)&forUnmarshaling->srcStageMask, *ptr,
-           sizeof(VkPipelineStageFlags2KHR));
-    *ptr += sizeof(VkPipelineStageFlags2KHR);
-    memcpy((VkAccessFlags2KHR*)&forUnmarshaling->srcAccessMask, *ptr, sizeof(VkAccessFlags2KHR));
-    *ptr += sizeof(VkAccessFlags2KHR);
-    memcpy((VkPipelineStageFlags2KHR*)&forUnmarshaling->dstStageMask, *ptr,
-           sizeof(VkPipelineStageFlags2KHR));
-    *ptr += sizeof(VkPipelineStageFlags2KHR);
-    memcpy((VkAccessFlags2KHR*)&forUnmarshaling->dstAccessMask, *ptr, sizeof(VkAccessFlags2KHR));
-    *ptr += sizeof(VkAccessFlags2KHR);
-    memcpy((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    uint64_t cgen_var_0;
-    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkBuffer*)&forUnmarshaling->buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
-    memcpy((VkDeviceSize*)&forUnmarshaling->offset, *ptr, sizeof(VkDeviceSize));
-    *ptr += sizeof(VkDeviceSize);
-    memcpy((VkDeviceSize*)&forUnmarshaling->size, *ptr, sizeof(VkDeviceSize));
-    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkVideoEncodeUsageFlagsKHR*)&forUnmarshaling->videoUsageHints, *ptr,
+           sizeof(VkVideoEncodeUsageFlagsKHR));
+    *ptr += sizeof(VkVideoEncodeUsageFlagsKHR);
+    memcpy((VkVideoEncodeContentFlagsKHR*)&forUnmarshaling->videoContentHints, *ptr,
+           sizeof(VkVideoEncodeContentFlagsKHR));
+    *ptr += sizeof(VkVideoEncodeContentFlagsKHR);
+    memcpy((VkVideoEncodeTuningModeKHR*)&forUnmarshaling->tuningMode, *ptr,
+           sizeof(VkVideoEncodeTuningModeKHR));
+    *ptr += sizeof(VkVideoEncodeTuningModeKHR);
 }
 
-void reservedunmarshal_VkImageMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkImageMemoryBarrier2KHR* forUnmarshaling,
-                                                uint8_t** ptr) {
+void reservedunmarshal_VkVideoEncodeRateControlLayerInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeRateControlLayerInfoKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12484,34 +14989,23 @@ void reservedunmarshal_VkImageMemoryBarrier2KHR(VulkanStream* vkStream, VkStruct
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkPipelineStageFlags2KHR*)&forUnmarshaling->srcStageMask, *ptr,
-           sizeof(VkPipelineStageFlags2KHR));
-    *ptr += sizeof(VkPipelineStageFlags2KHR);
-    memcpy((VkAccessFlags2KHR*)&forUnmarshaling->srcAccessMask, *ptr, sizeof(VkAccessFlags2KHR));
-    *ptr += sizeof(VkAccessFlags2KHR);
-    memcpy((VkPipelineStageFlags2KHR*)&forUnmarshaling->dstStageMask, *ptr,
-           sizeof(VkPipelineStageFlags2KHR));
-    *ptr += sizeof(VkPipelineStageFlags2KHR);
-    memcpy((VkAccessFlags2KHR*)&forUnmarshaling->dstAccessMask, *ptr, sizeof(VkAccessFlags2KHR));
-    *ptr += sizeof(VkAccessFlags2KHR);
-    memcpy((VkImageLayout*)&forUnmarshaling->oldLayout, *ptr, sizeof(VkImageLayout));
-    *ptr += sizeof(VkImageLayout);
-    memcpy((VkImageLayout*)&forUnmarshaling->newLayout, *ptr, sizeof(VkImageLayout));
-    *ptr += sizeof(VkImageLayout);
-    memcpy((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, *ptr, sizeof(uint32_t));
+    memcpy((uint64_t*)&forUnmarshaling->averageBitrate, *ptr, sizeof(uint64_t));
+    *ptr += sizeof(uint64_t);
+    memcpy((uint64_t*)&forUnmarshaling->maxBitrate, *ptr, sizeof(uint64_t));
+    *ptr += sizeof(uint64_t);
+    memcpy((uint32_t*)&forUnmarshaling->frameRateNumerator, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->frameRateDenominator, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->virtualBufferSizeInMs, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->initialVirtualBufferSizeInMs, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    uint64_t cgen_var_0;
-    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkImage*)&forUnmarshaling->image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
-    reservedunmarshal_VkImageSubresourceRange(
-        vkStream, rootType, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange), ptr);
 }
 
-void reservedunmarshal_VkDependencyInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkDependencyInfoKHR* forUnmarshaling, uint8_t** ptr) {
+void reservedunmarshal_VkVideoEncodeRateControlInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeRateControlInfoKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12534,81 +15028,29 @@ void reservedunmarshal_VkDependencyInfoKHR(VulkanStream* vkStream, VkStructureTy
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkDependencyFlags*)&forUnmarshaling->dependencyFlags, *ptr, sizeof(VkDependencyFlags));
-    *ptr += sizeof(VkDependencyFlags);
-    memcpy((uint32_t*)&forUnmarshaling->memoryBarrierCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pMemoryBarriers,
-                    forUnmarshaling->memoryBarrierCount * sizeof(const VkMemoryBarrier2KHR));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->memoryBarrierCount; ++i) {
-        reservedunmarshal_VkMemoryBarrier2KHR(
-            vkStream, rootType, (VkMemoryBarrier2KHR*)(forUnmarshaling->pMemoryBarriers + i), ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->bufferMemoryBarrierCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pBufferMemoryBarriers,
-        forUnmarshaling->bufferMemoryBarrierCount * sizeof(const VkBufferMemoryBarrier2KHR));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->bufferMemoryBarrierCount; ++i) {
-        reservedunmarshal_VkBufferMemoryBarrier2KHR(
-            vkStream, rootType,
-            (VkBufferMemoryBarrier2KHR*)(forUnmarshaling->pBufferMemoryBarriers + i), ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->imageMemoryBarrierCount, *ptr, sizeof(uint32_t));
+    memcpy((VkVideoEncodeRateControlFlagsKHR*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkVideoEncodeRateControlFlagsKHR));
+    *ptr += sizeof(VkVideoEncodeRateControlFlagsKHR);
+    memcpy((VkVideoEncodeRateControlModeFlagBitsKHR*)&forUnmarshaling->rateControlMode, *ptr,
+           sizeof(VkVideoEncodeRateControlModeFlagBitsKHR));
+    *ptr += sizeof(VkVideoEncodeRateControlModeFlagBitsKHR);
+    memcpy((uint32_t*)&forUnmarshaling->layerCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
     vkStream->alloc(
-        (void**)&forUnmarshaling->pImageMemoryBarriers,
-        forUnmarshaling->imageMemoryBarrierCount * sizeof(const VkImageMemoryBarrier2KHR));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->imageMemoryBarrierCount; ++i) {
-        reservedunmarshal_VkImageMemoryBarrier2KHR(
+        (void**)&forUnmarshaling->pLayers,
+        forUnmarshaling->layerCount * sizeof(const VkVideoEncodeRateControlLayerInfoKHR));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->layerCount; ++i) {
+        reservedunmarshal_VkVideoEncodeRateControlLayerInfoKHR(
             vkStream, rootType,
-            (VkImageMemoryBarrier2KHR*)(forUnmarshaling->pImageMemoryBarriers + i), ptr);
+            (VkVideoEncodeRateControlLayerInfoKHR*)(forUnmarshaling->pLayers + i), ptr);
     }
 }
 
-void reservedunmarshal_VkSemaphoreSubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkSemaphoreSubmitInfoKHR* forUnmarshaling,
-                                                uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    uint64_t cgen_var_0;
-    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkSemaphore*)&forUnmarshaling->semaphore =
-        (VkSemaphore)unbox_VkSemaphore((VkSemaphore)(*&cgen_var_0));
-    memcpy((uint64_t*)&forUnmarshaling->value, *ptr, sizeof(uint64_t));
-    *ptr += sizeof(uint64_t);
-    memcpy((VkPipelineStageFlags2KHR*)&forUnmarshaling->stageMask, *ptr,
-           sizeof(VkPipelineStageFlags2KHR));
-    *ptr += sizeof(VkPipelineStageFlags2KHR);
-    memcpy((uint32_t*)&forUnmarshaling->deviceIndex, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-}
-
-void reservedunmarshal_VkCommandBufferSubmitInfoKHR(VulkanStream* vkStream,
-                                                    VkStructureType rootType,
-                                                    VkCommandBufferSubmitInfoKHR* forUnmarshaling,
-                                                    uint8_t** ptr) {
+#endif
+#ifdef VK_KHR_synchronization2
+void reservedunmarshal_VkQueueFamilyCheckpointProperties2NV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkQueueFamilyCheckpointProperties2NV* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12631,17 +15073,13 @@ void reservedunmarshal_VkCommandBufferSubmitInfoKHR(VulkanStream* vkStream,
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    uint64_t cgen_var_0;
-    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkCommandBuffer*)&forUnmarshaling->commandBuffer =
-        (VkCommandBuffer)unbox_VkCommandBuffer((VkCommandBuffer)(*&cgen_var_0));
-    memcpy((uint32_t*)&forUnmarshaling->deviceMask, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
+    memcpy((VkPipelineStageFlags2*)&forUnmarshaling->checkpointExecutionStageMask, *ptr,
+           sizeof(VkPipelineStageFlags2));
+    *ptr += sizeof(VkPipelineStageFlags2);
 }
 
-void reservedunmarshal_VkSubmitInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                        VkSubmitInfo2KHR* forUnmarshaling, uint8_t** ptr) {
+void reservedunmarshal_VkCheckpointData2NV(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkCheckpointData2NV* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12664,43 +15102,24 @@ void reservedunmarshal_VkSubmitInfo2KHR(VulkanStream* vkStream, VkStructureType
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkSubmitFlagsKHR*)&forUnmarshaling->flags, *ptr, sizeof(VkSubmitFlagsKHR));
-    *ptr += sizeof(VkSubmitFlagsKHR);
-    memcpy((uint32_t*)&forUnmarshaling->waitSemaphoreInfoCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pWaitSemaphoreInfos,
-        forUnmarshaling->waitSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfoKHR));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->waitSemaphoreInfoCount; ++i) {
-        reservedunmarshal_VkSemaphoreSubmitInfoKHR(
-            vkStream, rootType,
-            (VkSemaphoreSubmitInfoKHR*)(forUnmarshaling->pWaitSemaphoreInfos + i), ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->commandBufferInfoCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pCommandBufferInfos,
-        forUnmarshaling->commandBufferInfoCount * sizeof(const VkCommandBufferSubmitInfoKHR));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->commandBufferInfoCount; ++i) {
-        reservedunmarshal_VkCommandBufferSubmitInfoKHR(
-            vkStream, rootType,
-            (VkCommandBufferSubmitInfoKHR*)(forUnmarshaling->pCommandBufferInfos + i), ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->signalSemaphoreInfoCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pSignalSemaphoreInfos,
-        forUnmarshaling->signalSemaphoreInfoCount * sizeof(const VkSemaphoreSubmitInfoKHR));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->signalSemaphoreInfoCount; ++i) {
-        reservedunmarshal_VkSemaphoreSubmitInfoKHR(
-            vkStream, rootType,
-            (VkSemaphoreSubmitInfoKHR*)(forUnmarshaling->pSignalSemaphoreInfos + i), ptr);
+    memcpy((VkPipelineStageFlags2*)&forUnmarshaling->stage, *ptr, sizeof(VkPipelineStageFlags2));
+    *ptr += sizeof(VkPipelineStageFlags2);
+    // WARNING PTR CHECK
+    memcpy((void**)&forUnmarshaling->pCheckpointMarker, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pCheckpointMarker);
+    *ptr += 8;
+    if (forUnmarshaling->pCheckpointMarker) {
+        vkStream->alloc((void**)&forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
+        memcpy((void*)forUnmarshaling->pCheckpointMarker, *ptr, sizeof(uint8_t));
+        *ptr += sizeof(uint8_t);
     }
 }
 
-void reservedunmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
+#endif
+#ifdef VK_KHR_fragment_shader_barycentric
+void reservedunmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceSynchronization2FeaturesKHR* forUnmarshaling, uint8_t** ptr) {
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12723,42 +15142,13 @@ void reservedunmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->synchronization2, *ptr, sizeof(VkBool32));
+    memcpy((VkBool32*)&forUnmarshaling->fragmentShaderBarycentric, *ptr, sizeof(VkBool32));
     *ptr += sizeof(VkBool32);
 }
 
-void reservedunmarshal_VkQueueFamilyCheckpointProperties2NV(
+void reservedunmarshal_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkQueueFamilyCheckpointProperties2NV* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((VkPipelineStageFlags2KHR*)&forUnmarshaling->checkpointExecutionStageMask, *ptr,
-           sizeof(VkPipelineStageFlags2KHR));
-    *ptr += sizeof(VkPipelineStageFlags2KHR);
-}
-
-void reservedunmarshal_VkCheckpointData2NV(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkCheckpointData2NV* forUnmarshaling, uint8_t** ptr) {
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12781,18 +15171,9 @@ void reservedunmarshal_VkCheckpointData2NV(VulkanStream* vkStream, VkStructureTy
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkPipelineStageFlags2KHR*)&forUnmarshaling->stage, *ptr,
-           sizeof(VkPipelineStageFlags2KHR));
-    *ptr += sizeof(VkPipelineStageFlags2KHR);
-    // WARNING PTR CHECK
-    memcpy((void**)&forUnmarshaling->pCheckpointMarker, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pCheckpointMarker);
-    *ptr += 8;
-    if (forUnmarshaling->pCheckpointMarker) {
-        vkStream->alloc((void**)&forUnmarshaling->pCheckpointMarker, sizeof(uint8_t));
-        memcpy((void*)forUnmarshaling->pCheckpointMarker, *ptr, sizeof(uint8_t));
-        *ptr += sizeof(uint8_t);
-    }
+    memcpy((VkBool32*)&forUnmarshaling->triStripVertexOrderIndependentOfProvokingVertex, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
 }
 
 #endif
@@ -12828,36 +15209,6 @@ void reservedunmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesK
 
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
-void reservedunmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((VkBool32*)&forUnmarshaling->shaderZeroInitializeWorkgroupMemory, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-}
-
 #endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
 void reservedunmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
@@ -12900,8 +15251,13 @@ void reservedunmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_copy_commands2
-void reservedunmarshal_VkBufferCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                        VkBufferCopy2KHR* forUnmarshaling, uint8_t** ptr) {
+#endif
+#ifdef VK_KHR_format_feature_flags2
+#endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+void reservedunmarshal_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -12924,477 +15280,63 @@ void reservedunmarshal_VkBufferCopy2KHR(VulkanStream* vkStream, VkStructureType
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkDeviceSize*)&forUnmarshaling->srcOffset, *ptr, sizeof(VkDeviceSize));
+    memcpy((VkBool32*)&forUnmarshaling->rayTracingMaintenance1, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->rayTracingPipelineTraceRaysIndirect2, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkTraceRaysIndirectCommand2KHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkTraceRaysIndirectCommand2KHR* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkDeviceAddress*)&forUnmarshaling->raygenShaderRecordAddress, *ptr,
+           sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+    memcpy((VkDeviceSize*)&forUnmarshaling->raygenShaderRecordSize, *ptr, sizeof(VkDeviceSize));
     *ptr += sizeof(VkDeviceSize);
-    memcpy((VkDeviceSize*)&forUnmarshaling->dstOffset, *ptr, sizeof(VkDeviceSize));
+    memcpy((VkDeviceAddress*)&forUnmarshaling->missShaderBindingTableAddress, *ptr,
+           sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+    memcpy((VkDeviceSize*)&forUnmarshaling->missShaderBindingTableSize, *ptr, sizeof(VkDeviceSize));
     *ptr += sizeof(VkDeviceSize);
-    memcpy((VkDeviceSize*)&forUnmarshaling->size, *ptr, sizeof(VkDeviceSize));
+    memcpy((VkDeviceSize*)&forUnmarshaling->missShaderBindingTableStride, *ptr,
+           sizeof(VkDeviceSize));
     *ptr += sizeof(VkDeviceSize);
-}
-
-void reservedunmarshal_VkCopyBufferInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                            VkCopyBufferInfo2KHR* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    uint64_t cgen_var_0;
-    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkBuffer*)&forUnmarshaling->srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
-    uint64_t cgen_var_1;
-    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkBuffer*)&forUnmarshaling->dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
-    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pRegions,
-                    forUnmarshaling->regionCount * sizeof(const VkBufferCopy2KHR));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
-        reservedunmarshal_VkBufferCopy2KHR(vkStream, rootType,
-                                           (VkBufferCopy2KHR*)(forUnmarshaling->pRegions + i), ptr);
-    }
-}
-
-void reservedunmarshal_VkImageCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                       VkImageCopy2KHR* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    reservedunmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource), ptr);
-    reservedunmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset),
-                                 ptr);
-    reservedunmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource), ptr);
-    reservedunmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset),
-                                 ptr);
-    reservedunmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent), ptr);
-}
-
-void reservedunmarshal_VkCopyImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkCopyImageInfo2KHR* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    uint64_t cgen_var_0;
-    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkImage*)&forUnmarshaling->srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
-    memcpy((VkImageLayout*)&forUnmarshaling->srcImageLayout, *ptr, sizeof(VkImageLayout));
-    *ptr += sizeof(VkImageLayout);
-    uint64_t cgen_var_1;
-    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkImage*)&forUnmarshaling->dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
-    memcpy((VkImageLayout*)&forUnmarshaling->dstImageLayout, *ptr, sizeof(VkImageLayout));
-    *ptr += sizeof(VkImageLayout);
-    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pRegions,
-                    forUnmarshaling->regionCount * sizeof(const VkImageCopy2KHR));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
-        reservedunmarshal_VkImageCopy2KHR(vkStream, rootType,
-                                          (VkImageCopy2KHR*)(forUnmarshaling->pRegions + i), ptr);
-    }
-}
-
-void reservedunmarshal_VkBufferImageCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                             VkBufferImageCopy2KHR* forUnmarshaling,
-                                             uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((VkDeviceSize*)&forUnmarshaling->bufferOffset, *ptr, sizeof(VkDeviceSize));
+    memcpy((VkDeviceAddress*)&forUnmarshaling->hitShaderBindingTableAddress, *ptr,
+           sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+    memcpy((VkDeviceSize*)&forUnmarshaling->hitShaderBindingTableSize, *ptr, sizeof(VkDeviceSize));
     *ptr += sizeof(VkDeviceSize);
-    memcpy((uint32_t*)&forUnmarshaling->bufferRowLength, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->bufferImageHeight, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    reservedunmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource), ptr);
-    reservedunmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset),
-                                 ptr);
-    reservedunmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent),
-                                 ptr);
-}
-
-void reservedunmarshal_VkCopyBufferToImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                   VkCopyBufferToImageInfo2KHR* forUnmarshaling,
-                                                   uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    uint64_t cgen_var_0;
-    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkBuffer*)&forUnmarshaling->srcBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
-    uint64_t cgen_var_1;
-    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkImage*)&forUnmarshaling->dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
-    memcpy((VkImageLayout*)&forUnmarshaling->dstImageLayout, *ptr, sizeof(VkImageLayout));
-    *ptr += sizeof(VkImageLayout);
-    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pRegions,
-                    forUnmarshaling->regionCount * sizeof(const VkBufferImageCopy2KHR));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
-        reservedunmarshal_VkBufferImageCopy2KHR(
-            vkStream, rootType, (VkBufferImageCopy2KHR*)(forUnmarshaling->pRegions + i), ptr);
-    }
-}
-
-void reservedunmarshal_VkCopyImageToBufferInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                   VkCopyImageToBufferInfo2KHR* forUnmarshaling,
-                                                   uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    uint64_t cgen_var_0;
-    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkImage*)&forUnmarshaling->srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
-    memcpy((VkImageLayout*)&forUnmarshaling->srcImageLayout, *ptr, sizeof(VkImageLayout));
-    *ptr += sizeof(VkImageLayout);
-    uint64_t cgen_var_1;
-    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkBuffer*)&forUnmarshaling->dstBuffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_1));
-    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pRegions,
-                    forUnmarshaling->regionCount * sizeof(const VkBufferImageCopy2KHR));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
-        reservedunmarshal_VkBufferImageCopy2KHR(
-            vkStream, rootType, (VkBufferImageCopy2KHR*)(forUnmarshaling->pRegions + i), ptr);
-    }
-}
-
-void reservedunmarshal_VkImageBlit2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                       VkImageBlit2KHR* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    reservedunmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource), ptr);
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        reservedunmarshal_VkOffset3D(vkStream, rootType,
-                                     (VkOffset3D*)(forUnmarshaling->srcOffsets + i), ptr);
-    }
-    reservedunmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource), ptr);
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        reservedunmarshal_VkOffset3D(vkStream, rootType,
-                                     (VkOffset3D*)(forUnmarshaling->dstOffsets + i), ptr);
-    }
-}
-
-void reservedunmarshal_VkBlitImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkBlitImageInfo2KHR* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    uint64_t cgen_var_0;
-    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkImage*)&forUnmarshaling->srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
-    memcpy((VkImageLayout*)&forUnmarshaling->srcImageLayout, *ptr, sizeof(VkImageLayout));
-    *ptr += sizeof(VkImageLayout);
-    uint64_t cgen_var_1;
-    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkImage*)&forUnmarshaling->dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
-    memcpy((VkImageLayout*)&forUnmarshaling->dstImageLayout, *ptr, sizeof(VkImageLayout));
-    *ptr += sizeof(VkImageLayout);
-    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pRegions,
-                    forUnmarshaling->regionCount * sizeof(const VkImageBlit2KHR));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
-        reservedunmarshal_VkImageBlit2KHR(vkStream, rootType,
-                                          (VkImageBlit2KHR*)(forUnmarshaling->pRegions + i), ptr);
-    }
-    memcpy((VkFilter*)&forUnmarshaling->filter, *ptr, sizeof(VkFilter));
-    *ptr += sizeof(VkFilter);
-}
-
-void reservedunmarshal_VkImageResolve2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                          VkImageResolve2KHR* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    memcpy((VkDeviceSize*)&forUnmarshaling->hitShaderBindingTableStride, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceAddress*)&forUnmarshaling->callableShaderBindingTableAddress, *ptr,
+           sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+    memcpy((VkDeviceSize*)&forUnmarshaling->callableShaderBindingTableSize, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceSize*)&forUnmarshaling->callableShaderBindingTableStride, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((uint32_t*)&forUnmarshaling->width, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    reservedunmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->srcSubresource), ptr);
-    reservedunmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->srcOffset),
-                                 ptr);
-    reservedunmarshal_VkImageSubresourceLayers(
-        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->dstSubresource), ptr);
-    reservedunmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->dstOffset),
-                                 ptr);
-    reservedunmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->extent), ptr);
-}
-
-void reservedunmarshal_VkResolveImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                              VkResolveImageInfo2KHR* forUnmarshaling,
-                                              uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    memcpy((uint32_t*)&forUnmarshaling->height, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    uint64_t cgen_var_0;
-    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkImage*)&forUnmarshaling->srcImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
-    memcpy((VkImageLayout*)&forUnmarshaling->srcImageLayout, *ptr, sizeof(VkImageLayout));
-    *ptr += sizeof(VkImageLayout);
-    uint64_t cgen_var_1;
-    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
-    *ptr += 1 * 8;
-    *(VkImage*)&forUnmarshaling->dstImage = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_1));
-    memcpy((VkImageLayout*)&forUnmarshaling->dstImageLayout, *ptr, sizeof(VkImageLayout));
-    *ptr += sizeof(VkImageLayout);
-    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->depth, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pRegions,
-                    forUnmarshaling->regionCount * sizeof(const VkImageResolve2KHR));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
-        reservedunmarshal_VkImageResolve2KHR(
-            vkStream, rootType, (VkImageResolve2KHR*)(forUnmarshaling->pRegions + i), ptr);
-    }
 }
 
 #endif
-#ifdef VK_KHR_format_feature_flags2
-void reservedunmarshal_VkFormatProperties3KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                              VkFormatProperties3KHR* forUnmarshaling,
-                                              uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((VkFormatFeatureFlags2KHR*)&forUnmarshaling->linearTilingFeatures, *ptr,
-           sizeof(VkFormatFeatureFlags2KHR));
-    *ptr += sizeof(VkFormatFeatureFlags2KHR);
-    memcpy((VkFormatFeatureFlags2KHR*)&forUnmarshaling->optimalTilingFeatures, *ptr,
-           sizeof(VkFormatFeatureFlags2KHR));
-    *ptr += sizeof(VkFormatFeatureFlags2KHR);
-    memcpy((VkFormatFeatureFlags2KHR*)&forUnmarshaling->bufferFeatures, *ptr,
-           sizeof(VkFormatFeatureFlags2KHR));
-    *ptr += sizeof(VkFormatFeatureFlags2KHR);
-}
-
+#ifdef VK_KHR_portability_enumeration
 #endif
 #ifdef VK_KHR_maintenance4
-void reservedunmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+void reservedunmarshal_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceMaintenance4FeaturesKHR* forUnmarshaling, uint8_t** ptr) {
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -13417,42 +15359,24 @@ void reservedunmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->maintenance4, *ptr, sizeof(VkBool32));
+    memcpy((VkBool32*)&forUnmarshaling->rayTracingPositionFetch, *ptr, sizeof(VkBool32));
     *ptr += sizeof(VkBool32);
 }
 
-void reservedunmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceMaintenance4PropertiesKHR* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((VkDeviceSize*)&forUnmarshaling->maxBufferSize, *ptr, sizeof(VkDeviceSize));
-    *ptr += sizeof(VkDeviceSize);
+#endif
+#ifdef VK_ANDROID_native_buffer
+void reservedunmarshal_VkNativeBufferUsage2ANDROID(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkNativeBufferUsage2ANDROID* forUnmarshaling,
+                                                   uint8_t** ptr) {
+    memcpy((uint64_t*)&forUnmarshaling->consumer, *ptr, sizeof(uint64_t));
+    *ptr += sizeof(uint64_t);
+    memcpy((uint64_t*)&forUnmarshaling->producer, *ptr, sizeof(uint64_t));
+    *ptr += sizeof(uint64_t);
 }
 
-void reservedunmarshal_VkDeviceBufferMemoryRequirementsKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceBufferMemoryRequirementsKHR* forUnmarshaling, uint8_t** ptr) {
+void reservedunmarshal_VkNativeBufferANDROID(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkNativeBufferANDROID* forUnmarshaling,
+                                             uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -13475,14 +15399,28 @@ void reservedunmarshal_VkDeviceBufferMemoryRequirementsKHR(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    vkStream->alloc((void**)&forUnmarshaling->pCreateInfo, sizeof(const VkBufferCreateInfo));
-    reservedunmarshal_VkBufferCreateInfo(vkStream, rootType,
-                                         (VkBufferCreateInfo*)(forUnmarshaling->pCreateInfo), ptr);
+    // WARNING PTR CHECK
+    memcpy((uint32_t**)&forUnmarshaling->handle, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->handle);
+    *ptr += 8;
+    if (forUnmarshaling->handle) {
+        vkStream->alloc((void**)&forUnmarshaling->handle, sizeof(const uint32_t));
+        memcpy((uint32_t*)forUnmarshaling->handle, *ptr, sizeof(const uint32_t));
+        *ptr += sizeof(const uint32_t);
+    }
+    memcpy((int*)&forUnmarshaling->stride, *ptr, sizeof(int));
+    *ptr += sizeof(int);
+    memcpy((int*)&forUnmarshaling->format, *ptr, sizeof(int));
+    *ptr += sizeof(int);
+    memcpy((int*)&forUnmarshaling->usage, *ptr, sizeof(int));
+    *ptr += sizeof(int);
+    reservedunmarshal_VkNativeBufferUsage2ANDROID(
+        vkStream, rootType, (VkNativeBufferUsage2ANDROID*)(&forUnmarshaling->usage2), ptr);
 }
 
-void reservedunmarshal_VkDeviceImageMemoryRequirementsKHR(
+void reservedunmarshal_VkSwapchainImageCreateInfoANDROID(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceImageMemoryRequirementsKHR* forUnmarshaling, uint8_t** ptr) {
+    VkSwapchainImageCreateInfoANDROID* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -13505,19 +15443,14 @@ void reservedunmarshal_VkDeviceImageMemoryRequirementsKHR(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    vkStream->alloc((void**)&forUnmarshaling->pCreateInfo, sizeof(const VkImageCreateInfo));
-    reservedunmarshal_VkImageCreateInfo(vkStream, rootType,
-                                        (VkImageCreateInfo*)(forUnmarshaling->pCreateInfo), ptr);
-    memcpy((VkImageAspectFlagBits*)&forUnmarshaling->planeAspect, *ptr,
-           sizeof(VkImageAspectFlagBits));
-    *ptr += sizeof(VkImageAspectFlagBits);
+    memcpy((VkSwapchainImageUsageFlagsANDROID*)&forUnmarshaling->usage, *ptr,
+           sizeof(VkSwapchainImageUsageFlagsANDROID));
+    *ptr += sizeof(VkSwapchainImageUsageFlagsANDROID);
 }
 
-#endif
-#ifdef VK_ANDROID_native_buffer
-void reservedunmarshal_VkNativeBufferANDROID(VulkanStream* vkStream, VkStructureType rootType,
-                                             VkNativeBufferANDROID* forUnmarshaling,
-                                             uint8_t** ptr) {
+void reservedunmarshal_VkPhysicalDevicePresentationPropertiesANDROID(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePresentationPropertiesANDROID* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -13540,25 +15473,8 @@ void reservedunmarshal_VkNativeBufferANDROID(VulkanStream* vkStream, VkStructure
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    // WARNING PTR CHECK
-    memcpy((uint32_t**)&forUnmarshaling->handle, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->handle);
-    *ptr += 8;
-    if (forUnmarshaling->handle) {
-        vkStream->alloc((void**)&forUnmarshaling->handle, sizeof(const uint32_t));
-        memcpy((uint32_t*)forUnmarshaling->handle, *ptr, sizeof(const uint32_t));
-        *ptr += sizeof(const uint32_t);
-    }
-    memcpy((int*)&forUnmarshaling->stride, *ptr, sizeof(int));
-    *ptr += sizeof(int);
-    memcpy((int*)&forUnmarshaling->format, *ptr, sizeof(int));
-    *ptr += sizeof(int);
-    memcpy((int*)&forUnmarshaling->usage, *ptr, sizeof(int));
-    *ptr += sizeof(int);
-    memcpy((uint64_t*)&forUnmarshaling->consumer, *ptr, sizeof(uint64_t));
-    *ptr += sizeof(uint64_t);
-    memcpy((uint64_t*)&forUnmarshaling->producer, *ptr, sizeof(uint64_t));
-    *ptr += sizeof(uint64_t);
+    memcpy((VkBool32*)&forUnmarshaling->sharedImage, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
 }
 
 #endif
@@ -14191,64 +16107,22 @@ void reservedunmarshal_VkVideoEncodeH264CapabilitiesEXT(
     memcpy((VkVideoEncodeH264CapabilityFlagsEXT*)&forUnmarshaling->flags, *ptr,
            sizeof(VkVideoEncodeH264CapabilityFlagsEXT));
     *ptr += sizeof(VkVideoEncodeH264CapabilityFlagsEXT);
-    memcpy((VkVideoEncodeH264InputModeFlagsEXT*)&forUnmarshaling->inputModeFlags, *ptr,
-           sizeof(VkVideoEncodeH264InputModeFlagsEXT));
-    *ptr += sizeof(VkVideoEncodeH264InputModeFlagsEXT);
-    memcpy((VkVideoEncodeH264OutputModeFlagsEXT*)&forUnmarshaling->outputModeFlags, *ptr,
-           sizeof(VkVideoEncodeH264OutputModeFlagsEXT));
-    *ptr += sizeof(VkVideoEncodeH264OutputModeFlagsEXT);
-    reservedunmarshal_VkExtent2D(vkStream, rootType,
-                                 (VkExtent2D*)(&forUnmarshaling->minPictureSizeInMbs), ptr);
-    reservedunmarshal_VkExtent2D(vkStream, rootType,
-                                 (VkExtent2D*)(&forUnmarshaling->maxPictureSizeInMbs), ptr);
-    reservedunmarshal_VkExtent2D(vkStream, rootType,
-                                 (VkExtent2D*)(&forUnmarshaling->inputImageDataAlignment), ptr);
-    memcpy((uint8_t*)&forUnmarshaling->maxNumL0ReferenceForP, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    memcpy((uint8_t*)&forUnmarshaling->maxNumL0ReferenceForB, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    memcpy((uint8_t*)&forUnmarshaling->maxNumL1Reference, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    memcpy((uint8_t*)&forUnmarshaling->qualityLevelCount, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    reservedunmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion), ptr);
-}
-
-void reservedunmarshal_VkVideoEncodeH264SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH264SessionCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    memcpy((uint32_t*)&forUnmarshaling->maxPPictureL0ReferenceCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxBPictureL0ReferenceCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxL1ReferenceCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((VkBool32*)&forUnmarshaling->motionVectorsOverPicBoundariesFlag, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((uint32_t*)&forUnmarshaling->maxBytesPerPicDenom, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxBitsPerMbDenom, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->log2MaxMvLengthHorizontal, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->log2MaxMvLengthVertical, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((VkVideoEncodeH264CreateFlagsEXT*)&forUnmarshaling->flags, *ptr,
-           sizeof(VkVideoEncodeH264CreateFlagsEXT));
-    *ptr += sizeof(VkVideoEncodeH264CreateFlagsEXT);
-    reservedunmarshal_VkExtent2D(vkStream, rootType,
-                                 (VkExtent2D*)(&forUnmarshaling->maxPictureSizeInMbs), ptr);
-    vkStream->alloc((void**)&forUnmarshaling->pStdExtensionVersion,
-                    sizeof(const VkExtensionProperties));
-    reservedunmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion), ptr);
 }
 
 void reservedunmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
@@ -14276,33 +16150,33 @@ void reservedunmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((uint32_t*)&forUnmarshaling->spsStdCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->stdSPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
     // WARNING PTR CHECK
-    memcpy((StdVideoH264SequenceParameterSet**)&forUnmarshaling->pSpsStd, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pSpsStd);
+    memcpy((StdVideoH264SequenceParameterSet**)&forUnmarshaling->pStdSPSs, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pStdSPSs);
     *ptr += 8;
-    if (forUnmarshaling->pSpsStd) {
+    if (forUnmarshaling->pStdSPSs) {
         vkStream->alloc(
-            (void**)&forUnmarshaling->pSpsStd,
-            forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
-        memcpy((StdVideoH264SequenceParameterSet*)forUnmarshaling->pSpsStd, *ptr,
-               forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
-        *ptr += forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet);
+            (void**)&forUnmarshaling->pStdSPSs,
+            forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
+        memcpy((StdVideoH264SequenceParameterSet*)forUnmarshaling->pStdSPSs, *ptr,
+               forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet));
+        *ptr += forUnmarshaling->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet);
     }
-    memcpy((uint32_t*)&forUnmarshaling->ppsStdCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->stdPPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
     // WARNING PTR CHECK
-    memcpy((StdVideoH264PictureParameterSet**)&forUnmarshaling->pPpsStd, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pPpsStd);
+    memcpy((StdVideoH264PictureParameterSet**)&forUnmarshaling->pStdPPSs, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pStdPPSs);
     *ptr += 8;
-    if (forUnmarshaling->pPpsStd) {
+    if (forUnmarshaling->pStdPPSs) {
         vkStream->alloc(
-            (void**)&forUnmarshaling->pPpsStd,
-            forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
-        memcpy((StdVideoH264PictureParameterSet*)forUnmarshaling->pPpsStd, *ptr,
-               forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
-        *ptr += forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet);
+            (void**)&forUnmarshaling->pStdPPSs,
+            forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
+        memcpy((StdVideoH264PictureParameterSet*)forUnmarshaling->pStdPPSs, *ptr,
+               forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet));
+        *ptr += forUnmarshaling->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet);
     }
 }
 
@@ -14331,9 +16205,9 @@ void reservedunmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((uint32_t*)&forUnmarshaling->maxSpsStdCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->maxStdSPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->maxPpsStdCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->maxStdPPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
     // WARNING PTR CHECK
     memcpy((VkVideoEncodeH264SessionParametersAddInfoEXT**)&forUnmarshaling->pParametersAddInfo,
@@ -14350,9 +16224,9 @@ void reservedunmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     }
 }
 
-void reservedunmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+void reservedunmarshal_VkVideoEncodeH264NaluSliceInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH264DpbSlotInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    VkVideoEncodeH264NaluSliceInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -14375,19 +16249,30 @@ void reservedunmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((int8_t*)&forUnmarshaling->slotIndex, *ptr, sizeof(int8_t));
-    *ptr += sizeof(int8_t);
-    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
-                    sizeof(const StdVideoEncodeH264PictureInfo));
-    memcpy((StdVideoEncodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo, *ptr,
-           sizeof(const StdVideoEncodeH264PictureInfo));
-    *ptr += sizeof(const StdVideoEncodeH264PictureInfo);
+    memcpy((uint32_t*)&forUnmarshaling->mbCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    // WARNING PTR CHECK
+    memcpy((StdVideoEncodeH264ReferenceListsInfo**)&forUnmarshaling->pStdReferenceFinalLists,
+           (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pStdReferenceFinalLists);
+    *ptr += 8;
+    if (forUnmarshaling->pStdReferenceFinalLists) {
+        vkStream->alloc((void**)&forUnmarshaling->pStdReferenceFinalLists,
+                        sizeof(const StdVideoEncodeH264ReferenceListsInfo));
+        memcpy((StdVideoEncodeH264ReferenceListsInfo*)forUnmarshaling->pStdReferenceFinalLists,
+               *ptr, sizeof(const StdVideoEncodeH264ReferenceListsInfo));
+        *ptr += sizeof(const StdVideoEncodeH264ReferenceListsInfo);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pStdSliceHeader,
+                    sizeof(const StdVideoEncodeH264SliceHeader));
+    memcpy((StdVideoEncodeH264SliceHeader*)forUnmarshaling->pStdSliceHeader, *ptr,
+           sizeof(const StdVideoEncodeH264SliceHeader));
+    *ptr += sizeof(const StdVideoEncodeH264SliceHeader);
 }
 
-void reservedunmarshal_VkVideoEncodeH264NaluSliceEXT(VulkanStream* vkStream,
-                                                     VkStructureType rootType,
-                                                     VkVideoEncodeH264NaluSliceEXT* forUnmarshaling,
-                                                     uint8_t** ptr) {
+void reservedunmarshal_VkVideoEncodeH264VclFrameInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH264VclFrameInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -14410,44 +16295,38 @@ void reservedunmarshal_VkVideoEncodeH264NaluSliceEXT(VulkanStream* vkStream,
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    vkStream->alloc((void**)&forUnmarshaling->pSliceHeaderStd,
-                    sizeof(const StdVideoEncodeH264SliceHeader));
-    memcpy((StdVideoEncodeH264SliceHeader*)forUnmarshaling->pSliceHeaderStd, *ptr,
-           sizeof(const StdVideoEncodeH264SliceHeader));
-    *ptr += sizeof(const StdVideoEncodeH264SliceHeader);
-    memcpy((uint32_t*)&forUnmarshaling->mbCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((uint8_t*)&forUnmarshaling->refFinalList0EntryCount, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pRefFinalList0Entries,
-        forUnmarshaling->refFinalList0EntryCount * sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refFinalList0EntryCount; ++i) {
-        reservedunmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
-            vkStream, rootType,
-            (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefFinalList0Entries + i), ptr);
+    // WARNING PTR CHECK
+    memcpy((StdVideoEncodeH264ReferenceListsInfo**)&forUnmarshaling->pStdReferenceFinalLists,
+           (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pStdReferenceFinalLists);
+    *ptr += 8;
+    if (forUnmarshaling->pStdReferenceFinalLists) {
+        vkStream->alloc((void**)&forUnmarshaling->pStdReferenceFinalLists,
+                        sizeof(const StdVideoEncodeH264ReferenceListsInfo));
+        memcpy((StdVideoEncodeH264ReferenceListsInfo*)forUnmarshaling->pStdReferenceFinalLists,
+               *ptr, sizeof(const StdVideoEncodeH264ReferenceListsInfo));
+        *ptr += sizeof(const StdVideoEncodeH264ReferenceListsInfo);
     }
-    memcpy((uint8_t*)&forUnmarshaling->refFinalList1EntryCount, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
+    memcpy((uint32_t*)&forUnmarshaling->naluSliceEntryCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
     vkStream->alloc(
-        (void**)&forUnmarshaling->pRefFinalList1Entries,
-        forUnmarshaling->refFinalList1EntryCount * sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refFinalList1EntryCount; ++i) {
-        reservedunmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+        (void**)&forUnmarshaling->pNaluSliceEntries,
+        forUnmarshaling->naluSliceEntryCount * sizeof(const VkVideoEncodeH264NaluSliceInfoEXT));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceEntryCount; ++i) {
+        reservedunmarshal_VkVideoEncodeH264NaluSliceInfoEXT(
             vkStream, rootType,
-            (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefFinalList1Entries + i), ptr);
+            (VkVideoEncodeH264NaluSliceInfoEXT*)(forUnmarshaling->pNaluSliceEntries + i), ptr);
     }
-    memcpy((uint32_t*)&forUnmarshaling->precedingNaluBytes, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((uint8_t*)&forUnmarshaling->minQp, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    memcpy((uint8_t*)&forUnmarshaling->maxQp, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
+    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
+                    sizeof(const StdVideoEncodeH264PictureInfo));
+    memcpy((StdVideoEncodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo, *ptr,
+           sizeof(const StdVideoEncodeH264PictureInfo));
+    *ptr += sizeof(const StdVideoEncodeH264PictureInfo);
 }
 
-void reservedunmarshal_VkVideoEncodeH264VclFrameInfoEXT(
+void reservedunmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH264VclFrameInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    VkVideoEncodeH264DpbSlotInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -14470,48 +16349,16 @@ void reservedunmarshal_VkVideoEncodeH264VclFrameInfoEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((uint8_t*)&forUnmarshaling->refDefaultFinalList0EntryCount, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    vkStream->alloc((void**)&forUnmarshaling->pRefDefaultFinalList0Entries,
-                    forUnmarshaling->refDefaultFinalList0EntryCount *
-                        sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refDefaultFinalList0EntryCount; ++i) {
-        reservedunmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
-            vkStream, rootType,
-            (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefDefaultFinalList0Entries + i),
-            ptr);
-    }
-    memcpy((uint8_t*)&forUnmarshaling->refDefaultFinalList1EntryCount, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    vkStream->alloc((void**)&forUnmarshaling->pRefDefaultFinalList1Entries,
-                    forUnmarshaling->refDefaultFinalList1EntryCount *
-                        sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->refDefaultFinalList1EntryCount; ++i) {
-        reservedunmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
-            vkStream, rootType,
-            (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pRefDefaultFinalList1Entries + i),
-            ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->naluSliceEntryCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pNaluSliceEntries,
-        forUnmarshaling->naluSliceEntryCount * sizeof(const VkVideoEncodeH264NaluSliceEXT));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceEntryCount; ++i) {
-        reservedunmarshal_VkVideoEncodeH264NaluSliceEXT(
-            vkStream, rootType,
-            (VkVideoEncodeH264NaluSliceEXT*)(forUnmarshaling->pNaluSliceEntries + i), ptr);
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pCurrentPictureInfo,
-                    sizeof(const VkVideoEncodeH264DpbSlotInfoEXT));
-    reservedunmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
-        vkStream, rootType,
-        (VkVideoEncodeH264DpbSlotInfoEXT*)(forUnmarshaling->pCurrentPictureInfo), ptr);
+    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
+                    sizeof(const StdVideoEncodeH264ReferenceInfo));
+    memcpy((StdVideoEncodeH264ReferenceInfo*)forUnmarshaling->pStdReferenceInfo, *ptr,
+           sizeof(const StdVideoEncodeH264ReferenceInfo));
+    *ptr += sizeof(const StdVideoEncodeH264ReferenceInfo);
 }
 
-void reservedunmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
+void reservedunmarshal_VkVideoEncodeH264ProfileInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH264EmitPictureParametersEXT* forUnmarshaling, uint8_t** ptr) {
+    VkVideoEncodeH264ProfileInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -14534,22 +16381,14 @@ void reservedunmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((uint8_t*)&forUnmarshaling->spsId, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    memcpy((VkBool32*)&forUnmarshaling->emitSpsEnable, *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((uint32_t*)&forUnmarshaling->ppsIdEntryCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->ppsIdEntries,
-                    forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t));
-    memcpy((uint8_t*)forUnmarshaling->ppsIdEntries, *ptr,
-           forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t));
-    *ptr += forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t);
+    memcpy((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc, *ptr,
+           sizeof(StdVideoH264ProfileIdc));
+    *ptr += sizeof(StdVideoH264ProfileIdc);
 }
 
-void reservedunmarshal_VkVideoEncodeH264ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                   VkVideoEncodeH264ProfileEXT* forUnmarshaling,
-                                                   uint8_t** ptr) {
+void reservedunmarshal_VkVideoEncodeH264RateControlInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH264RateControlInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -14572,16 +16411,45 @@ void reservedunmarshal_VkVideoEncodeH264ProfileEXT(VulkanStream* vkStream, VkStr
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc, *ptr,
-           sizeof(StdVideoH264ProfileIdc));
-    *ptr += sizeof(StdVideoH264ProfileIdc);
+    memcpy((uint32_t*)&forUnmarshaling->gopFrameCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->idrPeriod, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->consecutiveBFrameCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((VkVideoEncodeH264RateControlStructureEXT*)&forUnmarshaling->rateControlStructure, *ptr,
+           sizeof(VkVideoEncodeH264RateControlStructureEXT));
+    *ptr += sizeof(VkVideoEncodeH264RateControlStructureEXT);
+    memcpy((uint32_t*)&forUnmarshaling->temporalLayerCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
 }
 
-#endif
-#ifdef VK_EXT_video_encode_h265
-void reservedunmarshal_VkVideoEncodeH265CapabilitiesEXT(
+void reservedunmarshal_VkVideoEncodeH264QpEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkVideoEncodeH264QpEXT* forUnmarshaling,
+                                              uint8_t** ptr) {
+    memcpy((int32_t*)&forUnmarshaling->qpI, *ptr, sizeof(int32_t));
+    *ptr += sizeof(int32_t);
+    memcpy((int32_t*)&forUnmarshaling->qpP, *ptr, sizeof(int32_t));
+    *ptr += sizeof(int32_t);
+    memcpy((int32_t*)&forUnmarshaling->qpB, *ptr, sizeof(int32_t));
+    *ptr += sizeof(int32_t);
+}
+
+void reservedunmarshal_VkVideoEncodeH264FrameSizeEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkVideoEncodeH264FrameSizeEXT* forUnmarshaling,
+                                                     uint8_t** ptr) {
+    memcpy((uint32_t*)&forUnmarshaling->frameISize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->framePSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->frameBSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkVideoEncodeH264RateControlLayerInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265CapabilitiesEXT* forUnmarshaling, uint8_t** ptr) {
+    VkVideoEncodeH264RateControlLayerInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -14604,37 +16472,31 @@ void reservedunmarshal_VkVideoEncodeH265CapabilitiesEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkVideoEncodeH265CapabilityFlagsEXT*)&forUnmarshaling->flags, *ptr,
-           sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
-    *ptr += sizeof(VkVideoEncodeH265CapabilityFlagsEXT);
-    memcpy((VkVideoEncodeH265InputModeFlagsEXT*)&forUnmarshaling->inputModeFlags, *ptr,
-           sizeof(VkVideoEncodeH265InputModeFlagsEXT));
-    *ptr += sizeof(VkVideoEncodeH265InputModeFlagsEXT);
-    memcpy((VkVideoEncodeH265OutputModeFlagsEXT*)&forUnmarshaling->outputModeFlags, *ptr,
-           sizeof(VkVideoEncodeH265OutputModeFlagsEXT));
-    *ptr += sizeof(VkVideoEncodeH265OutputModeFlagsEXT);
-    memcpy((VkVideoEncodeH265CtbSizeFlagsEXT*)&forUnmarshaling->ctbSizes, *ptr,
-           sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
-    *ptr += sizeof(VkVideoEncodeH265CtbSizeFlagsEXT);
-    reservedunmarshal_VkExtent2D(vkStream, rootType,
-                                 (VkExtent2D*)(&forUnmarshaling->inputImageDataAlignment), ptr);
-    memcpy((uint8_t*)&forUnmarshaling->maxNumL0ReferenceForP, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    memcpy((uint8_t*)&forUnmarshaling->maxNumL0ReferenceForB, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    memcpy((uint8_t*)&forUnmarshaling->maxNumL1Reference, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    memcpy((uint8_t*)&forUnmarshaling->maxNumSubLayers, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    memcpy((uint8_t*)&forUnmarshaling->qualityLevelCount, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    reservedunmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion), ptr);
+    memcpy((uint32_t*)&forUnmarshaling->temporalLayerId, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((VkBool32*)&forUnmarshaling->useInitialRcQp, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    reservedunmarshal_VkVideoEncodeH264QpEXT(
+        vkStream, rootType, (VkVideoEncodeH264QpEXT*)(&forUnmarshaling->initialRcQp), ptr);
+    memcpy((VkBool32*)&forUnmarshaling->useMinQp, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    reservedunmarshal_VkVideoEncodeH264QpEXT(
+        vkStream, rootType, (VkVideoEncodeH264QpEXT*)(&forUnmarshaling->minQp), ptr);
+    memcpy((VkBool32*)&forUnmarshaling->useMaxQp, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    reservedunmarshal_VkVideoEncodeH264QpEXT(
+        vkStream, rootType, (VkVideoEncodeH264QpEXT*)(&forUnmarshaling->maxQp), ptr);
+    memcpy((VkBool32*)&forUnmarshaling->useMaxFrameSize, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    reservedunmarshal_VkVideoEncodeH264FrameSizeEXT(
+        vkStream, rootType, (VkVideoEncodeH264FrameSizeEXT*)(&forUnmarshaling->maxFrameSize), ptr);
 }
 
-void reservedunmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
+#endif
+#ifdef VK_EXT_video_encode_h265
+void reservedunmarshal_VkVideoEncodeH265CapabilitiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265SessionCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    VkVideoEncodeH265CapabilitiesEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -14657,13 +16519,49 @@ void reservedunmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkVideoEncodeH265CreateFlagsEXT*)&forUnmarshaling->flags, *ptr,
-           sizeof(VkVideoEncodeH265CreateFlagsEXT));
-    *ptr += sizeof(VkVideoEncodeH265CreateFlagsEXT);
-    vkStream->alloc((void**)&forUnmarshaling->pStdExtensionVersion,
-                    sizeof(const VkExtensionProperties));
-    reservedunmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion), ptr);
+    memcpy((VkVideoEncodeH265CapabilityFlagsEXT*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkVideoEncodeH265CapabilityFlagsEXT));
+    *ptr += sizeof(VkVideoEncodeH265CapabilityFlagsEXT);
+    memcpy((VkVideoEncodeH265CtbSizeFlagsEXT*)&forUnmarshaling->ctbSizes, *ptr,
+           sizeof(VkVideoEncodeH265CtbSizeFlagsEXT));
+    *ptr += sizeof(VkVideoEncodeH265CtbSizeFlagsEXT);
+    memcpy((VkVideoEncodeH265TransformBlockSizeFlagsEXT*)&forUnmarshaling->transformBlockSizes,
+           *ptr, sizeof(VkVideoEncodeH265TransformBlockSizeFlagsEXT));
+    *ptr += sizeof(VkVideoEncodeH265TransformBlockSizeFlagsEXT);
+    memcpy((uint32_t*)&forUnmarshaling->maxPPictureL0ReferenceCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxBPictureL0ReferenceCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxL1ReferenceCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxSubLayersCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->minLog2MinLumaCodingBlockSizeMinus3, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxLog2MinLumaCodingBlockSizeMinus3, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->minLog2MinLumaTransformBlockSizeMinus2, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxLog2MinLumaTransformBlockSizeMinus2, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->minMaxTransformHierarchyDepthInter, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMaxTransformHierarchyDepthInter, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->minMaxTransformHierarchyDepthIntra, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMaxTransformHierarchyDepthIntra, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxDiffCuQpDeltaDepth, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->minMaxNumMergeCand, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMaxNumMergeCand, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
 }
 
 void reservedunmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
@@ -14691,46 +16589,46 @@ void reservedunmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((uint32_t*)&forUnmarshaling->vpsStdCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->stdVPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
     // WARNING PTR CHECK
-    memcpy((StdVideoH265VideoParameterSet**)&forUnmarshaling->pVpsStd, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pVpsStd);
+    memcpy((StdVideoH265VideoParameterSet**)&forUnmarshaling->pStdVPSs, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pStdVPSs);
     *ptr += 8;
-    if (forUnmarshaling->pVpsStd) {
-        vkStream->alloc((void**)&forUnmarshaling->pVpsStd,
-                        forUnmarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
-        memcpy((StdVideoH265VideoParameterSet*)forUnmarshaling->pVpsStd, *ptr,
-               forUnmarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet));
-        *ptr += forUnmarshaling->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet);
+    if (forUnmarshaling->pStdVPSs) {
+        vkStream->alloc((void**)&forUnmarshaling->pStdVPSs,
+                        forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
+        memcpy((StdVideoH265VideoParameterSet*)forUnmarshaling->pStdVPSs, *ptr,
+               forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet));
+        *ptr += forUnmarshaling->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet);
     }
-    memcpy((uint32_t*)&forUnmarshaling->spsStdCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->stdSPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
     // WARNING PTR CHECK
-    memcpy((StdVideoH265SequenceParameterSet**)&forUnmarshaling->pSpsStd, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pSpsStd);
+    memcpy((StdVideoH265SequenceParameterSet**)&forUnmarshaling->pStdSPSs, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pStdSPSs);
     *ptr += 8;
-    if (forUnmarshaling->pSpsStd) {
+    if (forUnmarshaling->pStdSPSs) {
         vkStream->alloc(
-            (void**)&forUnmarshaling->pSpsStd,
-            forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
-        memcpy((StdVideoH265SequenceParameterSet*)forUnmarshaling->pSpsStd, *ptr,
-               forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
-        *ptr += forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet);
+            (void**)&forUnmarshaling->pStdSPSs,
+            forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
+        memcpy((StdVideoH265SequenceParameterSet*)forUnmarshaling->pStdSPSs, *ptr,
+               forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet));
+        *ptr += forUnmarshaling->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet);
     }
-    memcpy((uint32_t*)&forUnmarshaling->ppsStdCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->stdPPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
     // WARNING PTR CHECK
-    memcpy((StdVideoH265PictureParameterSet**)&forUnmarshaling->pPpsStd, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pPpsStd);
+    memcpy((StdVideoH265PictureParameterSet**)&forUnmarshaling->pStdPPSs, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pStdPPSs);
     *ptr += 8;
-    if (forUnmarshaling->pPpsStd) {
+    if (forUnmarshaling->pStdPPSs) {
         vkStream->alloc(
-            (void**)&forUnmarshaling->pPpsStd,
-            forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
-        memcpy((StdVideoH265PictureParameterSet*)forUnmarshaling->pPpsStd, *ptr,
-               forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
-        *ptr += forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet);
+            (void**)&forUnmarshaling->pStdPPSs,
+            forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
+        memcpy((StdVideoH265PictureParameterSet*)forUnmarshaling->pStdPPSs, *ptr,
+               forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet));
+        *ptr += forUnmarshaling->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet);
     }
 }
 
@@ -14759,11 +16657,11 @@ void reservedunmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((uint32_t*)&forUnmarshaling->maxVpsStdCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->maxStdVPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->maxSpsStdCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->maxStdSPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->maxPpsStdCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->maxStdPPSCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
     // WARNING PTR CHECK
     memcpy((VkVideoEncodeH265SessionParametersAddInfoEXT**)&forUnmarshaling->pParametersAddInfo,
@@ -14780,96 +16678,9 @@ void reservedunmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
     }
 }
 
-void reservedunmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265DpbSlotInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((int8_t*)&forUnmarshaling->slotIndex, *ptr, sizeof(int8_t));
-    *ptr += sizeof(int8_t);
-    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
-                    sizeof(const StdVideoEncodeH265ReferenceInfo));
-    memcpy((StdVideoEncodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo, *ptr,
-           sizeof(const StdVideoEncodeH265ReferenceInfo));
-    *ptr += sizeof(const StdVideoEncodeH265ReferenceInfo);
-}
-
-void reservedunmarshal_VkVideoEncodeH265ReferenceListsEXT(
+void reservedunmarshal_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265ReferenceListsEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((uint8_t*)&forUnmarshaling->referenceList0EntryCount, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pReferenceList0Entries,
-        forUnmarshaling->referenceList0EntryCount * sizeof(const VkVideoEncodeH265DpbSlotInfoEXT));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceList0EntryCount; ++i) {
-        reservedunmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
-            vkStream, rootType,
-            (VkVideoEncodeH265DpbSlotInfoEXT*)(forUnmarshaling->pReferenceList0Entries + i), ptr);
-    }
-    memcpy((uint8_t*)&forUnmarshaling->referenceList1EntryCount, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pReferenceList1Entries,
-        forUnmarshaling->referenceList1EntryCount * sizeof(const VkVideoEncodeH265DpbSlotInfoEXT));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->referenceList1EntryCount; ++i) {
-        reservedunmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
-            vkStream, rootType,
-            (VkVideoEncodeH265DpbSlotInfoEXT*)(forUnmarshaling->pReferenceList1Entries + i), ptr);
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pReferenceModifications,
-                    sizeof(const StdVideoEncodeH265ReferenceModifications));
-    memcpy((StdVideoEncodeH265ReferenceModifications*)forUnmarshaling->pReferenceModifications,
-           *ptr, sizeof(const StdVideoEncodeH265ReferenceModifications));
-    *ptr += sizeof(const StdVideoEncodeH265ReferenceModifications);
-}
-
-void reservedunmarshal_VkVideoEncodeH265NaluSliceEXT(VulkanStream* vkStream,
-                                                     VkStructureType rootType,
-                                                     VkVideoEncodeH265NaluSliceEXT* forUnmarshaling,
-                                                     uint8_t** ptr) {
+    VkVideoEncodeH265NaluSliceSegmentInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -14895,21 +16706,22 @@ void reservedunmarshal_VkVideoEncodeH265NaluSliceEXT(VulkanStream* vkStream,
     memcpy((uint32_t*)&forUnmarshaling->ctbCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
     // WARNING PTR CHECK
-    memcpy((VkVideoEncodeH265ReferenceListsEXT**)&forUnmarshaling->pReferenceFinalLists, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pReferenceFinalLists);
+    memcpy((StdVideoEncodeH265ReferenceListsInfo**)&forUnmarshaling->pStdReferenceFinalLists,
+           (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pStdReferenceFinalLists);
     *ptr += 8;
-    if (forUnmarshaling->pReferenceFinalLists) {
-        vkStream->alloc((void**)&forUnmarshaling->pReferenceFinalLists,
-                        sizeof(const VkVideoEncodeH265ReferenceListsEXT));
-        reservedunmarshal_VkVideoEncodeH265ReferenceListsEXT(
-            vkStream, rootType,
-            (VkVideoEncodeH265ReferenceListsEXT*)(forUnmarshaling->pReferenceFinalLists), ptr);
+    if (forUnmarshaling->pStdReferenceFinalLists) {
+        vkStream->alloc((void**)&forUnmarshaling->pStdReferenceFinalLists,
+                        sizeof(const StdVideoEncodeH265ReferenceListsInfo));
+        memcpy((StdVideoEncodeH265ReferenceListsInfo*)forUnmarshaling->pStdReferenceFinalLists,
+               *ptr, sizeof(const StdVideoEncodeH265ReferenceListsInfo));
+        *ptr += sizeof(const StdVideoEncodeH265ReferenceListsInfo);
     }
-    vkStream->alloc((void**)&forUnmarshaling->pSliceHeaderStd,
-                    sizeof(const StdVideoEncodeH265SliceHeader));
-    memcpy((StdVideoEncodeH265SliceHeader*)forUnmarshaling->pSliceHeaderStd, *ptr,
-           sizeof(const StdVideoEncodeH265SliceHeader));
-    *ptr += sizeof(const StdVideoEncodeH265SliceHeader);
+    vkStream->alloc((void**)&forUnmarshaling->pStdSliceSegmentHeader,
+                    sizeof(const StdVideoEncodeH265SliceSegmentHeader));
+    memcpy((StdVideoEncodeH265SliceSegmentHeader*)forUnmarshaling->pStdSliceSegmentHeader, *ptr,
+           sizeof(const StdVideoEncodeH265SliceSegmentHeader));
+    *ptr += sizeof(const StdVideoEncodeH265SliceSegmentHeader);
 }
 
 void reservedunmarshal_VkVideoEncodeH265VclFrameInfoEXT(
@@ -14938,36 +16750,39 @@ void reservedunmarshal_VkVideoEncodeH265VclFrameInfoEXT(
                                            ptr);
     }
     // WARNING PTR CHECK
-    memcpy((VkVideoEncodeH265ReferenceListsEXT**)&forUnmarshaling->pReferenceFinalLists, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pReferenceFinalLists);
+    memcpy((StdVideoEncodeH265ReferenceListsInfo**)&forUnmarshaling->pStdReferenceFinalLists,
+           (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pStdReferenceFinalLists);
     *ptr += 8;
-    if (forUnmarshaling->pReferenceFinalLists) {
-        vkStream->alloc((void**)&forUnmarshaling->pReferenceFinalLists,
-                        sizeof(const VkVideoEncodeH265ReferenceListsEXT));
-        reservedunmarshal_VkVideoEncodeH265ReferenceListsEXT(
-            vkStream, rootType,
-            (VkVideoEncodeH265ReferenceListsEXT*)(forUnmarshaling->pReferenceFinalLists), ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->naluSliceEntryCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc(
-        (void**)&forUnmarshaling->pNaluSliceEntries,
-        forUnmarshaling->naluSliceEntryCount * sizeof(const VkVideoEncodeH265NaluSliceEXT));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceEntryCount; ++i) {
-        reservedunmarshal_VkVideoEncodeH265NaluSliceEXT(
+    if (forUnmarshaling->pStdReferenceFinalLists) {
+        vkStream->alloc((void**)&forUnmarshaling->pStdReferenceFinalLists,
+                        sizeof(const StdVideoEncodeH265ReferenceListsInfo));
+        memcpy((StdVideoEncodeH265ReferenceListsInfo*)forUnmarshaling->pStdReferenceFinalLists,
+               *ptr, sizeof(const StdVideoEncodeH265ReferenceListsInfo));
+        *ptr += sizeof(const StdVideoEncodeH265ReferenceListsInfo);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->naluSliceSegmentEntryCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pNaluSliceSegmentEntries,
+                    forUnmarshaling->naluSliceSegmentEntryCount *
+                        sizeof(const VkVideoEncodeH265NaluSliceSegmentInfoEXT));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->naluSliceSegmentEntryCount; ++i) {
+        reservedunmarshal_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
             vkStream, rootType,
-            (VkVideoEncodeH265NaluSliceEXT*)(forUnmarshaling->pNaluSliceEntries + i), ptr);
+            (VkVideoEncodeH265NaluSliceSegmentInfoEXT*)(forUnmarshaling->pNaluSliceSegmentEntries +
+                                                        i),
+            ptr);
     }
-    vkStream->alloc((void**)&forUnmarshaling->pCurrentPictureInfo,
+    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
                     sizeof(const StdVideoEncodeH265PictureInfo));
-    memcpy((StdVideoEncodeH265PictureInfo*)forUnmarshaling->pCurrentPictureInfo, *ptr,
+    memcpy((StdVideoEncodeH265PictureInfo*)forUnmarshaling->pStdPictureInfo, *ptr,
            sizeof(const StdVideoEncodeH265PictureInfo));
     *ptr += sizeof(const StdVideoEncodeH265PictureInfo);
 }
 
-void reservedunmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
+void reservedunmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265EmitPictureParametersEXT* forUnmarshaling, uint8_t** ptr) {
+    VkVideoEncodeH265DpbSlotInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -14990,26 +16805,16 @@ void reservedunmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((uint8_t*)&forUnmarshaling->vpsId, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    memcpy((uint8_t*)&forUnmarshaling->spsId, *ptr, sizeof(uint8_t));
-    *ptr += sizeof(uint8_t);
-    memcpy((VkBool32*)&forUnmarshaling->emitVpsEnable, *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->emitSpsEnable, *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((uint32_t*)&forUnmarshaling->ppsIdEntryCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->ppsIdEntries,
-                    forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t));
-    memcpy((uint8_t*)forUnmarshaling->ppsIdEntries, *ptr,
-           forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t));
-    *ptr += forUnmarshaling->ppsIdEntryCount * sizeof(const uint8_t);
+    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
+                    sizeof(const StdVideoEncodeH265ReferenceInfo));
+    memcpy((StdVideoEncodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo, *ptr,
+           sizeof(const StdVideoEncodeH265ReferenceInfo));
+    *ptr += sizeof(const StdVideoEncodeH265ReferenceInfo);
 }
 
-void reservedunmarshal_VkVideoEncodeH265ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                   VkVideoEncodeH265ProfileEXT* forUnmarshaling,
-                                                   uint8_t** ptr) {
+void reservedunmarshal_VkVideoEncodeH265ProfileInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH265ProfileInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -15037,44 +16842,9 @@ void reservedunmarshal_VkVideoEncodeH265ProfileEXT(VulkanStream* vkStream, VkStr
     *ptr += sizeof(StdVideoH265ProfileIdc);
 }
 
-#endif
-#ifdef VK_EXT_video_decode_h264
-void reservedunmarshal_VkVideoDecodeH264ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                   VkVideoDecodeH264ProfileEXT* forUnmarshaling,
-                                                   uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((StdVideoH264ProfileIdc*)&forUnmarshaling->stdProfileIdc, *ptr,
-           sizeof(StdVideoH264ProfileIdc));
-    *ptr += sizeof(StdVideoH264ProfileIdc);
-    memcpy((VkVideoDecodeH264PictureLayoutFlagsEXT*)&forUnmarshaling->pictureLayout, *ptr,
-           sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT));
-    *ptr += sizeof(VkVideoDecodeH264PictureLayoutFlagsEXT);
-}
-
-void reservedunmarshal_VkVideoDecodeH264CapabilitiesEXT(
+void reservedunmarshal_VkVideoEncodeH265RateControlInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264CapabilitiesEXT* forUnmarshaling, uint8_t** ptr) {
+    VkVideoEncodeH265RateControlInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -15097,220 +16867,45 @@ void reservedunmarshal_VkVideoDecodeH264CapabilitiesEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((uint32_t*)&forUnmarshaling->maxLevel, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    reservedunmarshal_VkOffset2D(vkStream, rootType,
-                                 (VkOffset2D*)(&forUnmarshaling->fieldOffsetGranularity), ptr);
-    reservedunmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion), ptr);
-}
-
-void reservedunmarshal_VkVideoDecodeH264SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264SessionCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    memcpy((uint32_t*)&forUnmarshaling->gopFrameCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((VkVideoDecodeH264CreateFlagsEXT*)&forUnmarshaling->flags, *ptr,
-           sizeof(VkVideoDecodeH264CreateFlagsEXT));
-    *ptr += sizeof(VkVideoDecodeH264CreateFlagsEXT);
-    vkStream->alloc((void**)&forUnmarshaling->pStdExtensionVersion,
-                    sizeof(const VkExtensionProperties));
-    reservedunmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion), ptr);
-}
-
-void reservedunmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264SessionParametersAddInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    memcpy((uint32_t*)&forUnmarshaling->idrPeriod, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->spsStdCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->consecutiveBFrameCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    // WARNING PTR CHECK
-    memcpy((StdVideoH264SequenceParameterSet**)&forUnmarshaling->pSpsStd, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pSpsStd);
-    *ptr += 8;
-    if (forUnmarshaling->pSpsStd) {
-        vkStream->alloc(
-            (void**)&forUnmarshaling->pSpsStd,
-            forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
-        memcpy((StdVideoH264SequenceParameterSet*)forUnmarshaling->pSpsStd, *ptr,
-               forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet));
-        *ptr += forUnmarshaling->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->ppsStdCount, *ptr, sizeof(uint32_t));
+    memcpy((VkVideoEncodeH265RateControlStructureEXT*)&forUnmarshaling->rateControlStructure, *ptr,
+           sizeof(VkVideoEncodeH265RateControlStructureEXT));
+    *ptr += sizeof(VkVideoEncodeH265RateControlStructureEXT);
+    memcpy((uint32_t*)&forUnmarshaling->subLayerCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    // WARNING PTR CHECK
-    memcpy((StdVideoH264PictureParameterSet**)&forUnmarshaling->pPpsStd, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pPpsStd);
-    *ptr += 8;
-    if (forUnmarshaling->pPpsStd) {
-        vkStream->alloc(
-            (void**)&forUnmarshaling->pPpsStd,
-            forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
-        memcpy((StdVideoH264PictureParameterSet*)forUnmarshaling->pPpsStd, *ptr,
-               forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet));
-        *ptr += forUnmarshaling->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet);
-    }
 }
 
-void reservedunmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264SessionParametersCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->maxSpsStdCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->maxPpsStdCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    // WARNING PTR CHECK
-    memcpy((VkVideoDecodeH264SessionParametersAddInfoEXT**)&forUnmarshaling->pParametersAddInfo,
-           (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pParametersAddInfo);
-    *ptr += 8;
-    if (forUnmarshaling->pParametersAddInfo) {
-        vkStream->alloc((void**)&forUnmarshaling->pParametersAddInfo,
-                        sizeof(const VkVideoDecodeH264SessionParametersAddInfoEXT));
-        reservedunmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
-            vkStream, rootType,
-            (VkVideoDecodeH264SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo),
-            ptr);
-    }
+void reservedunmarshal_VkVideoEncodeH265QpEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkVideoEncodeH265QpEXT* forUnmarshaling,
+                                              uint8_t** ptr) {
+    memcpy((int32_t*)&forUnmarshaling->qpI, *ptr, sizeof(int32_t));
+    *ptr += sizeof(int32_t);
+    memcpy((int32_t*)&forUnmarshaling->qpP, *ptr, sizeof(int32_t));
+    *ptr += sizeof(int32_t);
+    memcpy((int32_t*)&forUnmarshaling->qpB, *ptr, sizeof(int32_t));
+    *ptr += sizeof(int32_t);
 }
 
-void reservedunmarshal_VkVideoDecodeH264PictureInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264PictureInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+void reservedunmarshal_VkVideoEncodeH265FrameSizeEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkVideoEncodeH265FrameSizeEXT* forUnmarshaling,
+                                                     uint8_t** ptr) {
+    memcpy((uint32_t*)&forUnmarshaling->frameISize, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
-                    sizeof(const StdVideoDecodeH264PictureInfo));
-    memcpy((StdVideoDecodeH264PictureInfo*)forUnmarshaling->pStdPictureInfo, *ptr,
-           sizeof(const StdVideoDecodeH264PictureInfo));
-    *ptr += sizeof(const StdVideoDecodeH264PictureInfo);
-    memcpy((uint32_t*)&forUnmarshaling->slicesCount, *ptr, sizeof(uint32_t));
+    memcpy((uint32_t*)&forUnmarshaling->framePSize, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pSlicesDataOffsets,
-                    forUnmarshaling->slicesCount * sizeof(const uint32_t));
-    memcpy((uint32_t*)forUnmarshaling->pSlicesDataOffsets, *ptr,
-           forUnmarshaling->slicesCount * sizeof(const uint32_t));
-    *ptr += forUnmarshaling->slicesCount * sizeof(const uint32_t);
-}
-
-void reservedunmarshal_VkVideoDecodeH264MvcEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoDecodeH264MvcEXT* forUnmarshaling,
-                                               uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    memcpy((uint32_t*)&forUnmarshaling->frameBSize, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pStdMvc, sizeof(const StdVideoDecodeH264Mvc));
-    memcpy((StdVideoDecodeH264Mvc*)forUnmarshaling->pStdMvc, *ptr,
-           sizeof(const StdVideoDecodeH264Mvc));
-    *ptr += sizeof(const StdVideoDecodeH264Mvc);
 }
 
-void reservedunmarshal_VkVideoDecodeH264DpbSlotInfoEXT(
+void reservedunmarshal_VkVideoEncodeH265RateControlLayerInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264DpbSlotInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    VkVideoEncodeH265RateControlLayerInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -15333,11 +16928,24 @@ void reservedunmarshal_VkVideoDecodeH264DpbSlotInfoEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
-                    sizeof(const StdVideoDecodeH264ReferenceInfo));
-    memcpy((StdVideoDecodeH264ReferenceInfo*)forUnmarshaling->pStdReferenceInfo, *ptr,
-           sizeof(const StdVideoDecodeH264ReferenceInfo));
-    *ptr += sizeof(const StdVideoDecodeH264ReferenceInfo);
+    memcpy((uint32_t*)&forUnmarshaling->temporalId, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((VkBool32*)&forUnmarshaling->useInitialRcQp, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    reservedunmarshal_VkVideoEncodeH265QpEXT(
+        vkStream, rootType, (VkVideoEncodeH265QpEXT*)(&forUnmarshaling->initialRcQp), ptr);
+    memcpy((VkBool32*)&forUnmarshaling->useMinQp, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    reservedunmarshal_VkVideoEncodeH265QpEXT(
+        vkStream, rootType, (VkVideoEncodeH265QpEXT*)(&forUnmarshaling->minQp), ptr);
+    memcpy((VkBool32*)&forUnmarshaling->useMaxQp, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    reservedunmarshal_VkVideoEncodeH265QpEXT(
+        vkStream, rootType, (VkVideoEncodeH265QpEXT*)(&forUnmarshaling->maxQp), ptr);
+    memcpy((VkBool32*)&forUnmarshaling->useMaxFrameSize, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    reservedunmarshal_VkVideoEncodeH265FrameSizeEXT(
+        vkStream, rootType, (VkVideoEncodeH265FrameSizeEXT*)(&forUnmarshaling->maxFrameSize), ptr);
 }
 
 #endif
@@ -15794,9 +17402,41 @@ void reservedunmarshal_VkViSurfaceCreateInfoNN(VulkanStream* vkStream, VkStructu
 #ifdef VK_EXT_shader_subgroup_vote
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
-void reservedunmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
+#endif
+#ifdef VK_EXT_astc_decode_mode
+void reservedunmarshal_VkImageViewASTCDecodeModeEXT(VulkanStream* vkStream,
+                                                    VkStructureType rootType,
+                                                    VkImageViewASTCDecodeModeEXT* forUnmarshaling,
+                                                    uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkFormat*)&forUnmarshaling->decodeMode, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+}
+
+void reservedunmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    VkPhysicalDeviceASTCDecodeFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -15819,16 +17459,15 @@ void reservedunmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->textureCompressionASTC_HDR, *ptr, sizeof(VkBool32));
+    memcpy((VkBool32*)&forUnmarshaling->decodeModeSharedExponent, *ptr, sizeof(VkBool32));
     *ptr += sizeof(VkBool32);
 }
 
 #endif
-#ifdef VK_EXT_astc_decode_mode
-void reservedunmarshal_VkImageViewASTCDecodeModeEXT(VulkanStream* vkStream,
-                                                    VkStructureType rootType,
-                                                    VkImageViewASTCDecodeModeEXT* forUnmarshaling,
-                                                    uint8_t** ptr) {
+#ifdef VK_EXT_pipeline_robustness
+void reservedunmarshal_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -15851,13 +17490,13 @@ void reservedunmarshal_VkImageViewASTCDecodeModeEXT(VulkanStream* vkStream,
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkFormat*)&forUnmarshaling->decodeMode, *ptr, sizeof(VkFormat));
-    *ptr += sizeof(VkFormat);
+    memcpy((VkBool32*)&forUnmarshaling->pipelineRobustness, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
 }
 
-void reservedunmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+void reservedunmarshal_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceASTCDecodeFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -15880,8 +17519,59 @@ void reservedunmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->decodeModeSharedExponent, *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
+    memcpy(
+        (VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->defaultRobustnessStorageBuffers,
+        *ptr, sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    *ptr += sizeof(VkPipelineRobustnessBufferBehaviorEXT);
+    memcpy(
+        (VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->defaultRobustnessUniformBuffers,
+        *ptr, sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    *ptr += sizeof(VkPipelineRobustnessBufferBehaviorEXT);
+    memcpy((VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->defaultRobustnessVertexInputs,
+           *ptr, sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    *ptr += sizeof(VkPipelineRobustnessBufferBehaviorEXT);
+    memcpy((VkPipelineRobustnessImageBehaviorEXT*)&forUnmarshaling->defaultRobustnessImages, *ptr,
+           sizeof(VkPipelineRobustnessImageBehaviorEXT));
+    *ptr += sizeof(VkPipelineRobustnessImageBehaviorEXT);
+}
+
+void reservedunmarshal_VkPipelineRobustnessCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineRobustnessCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->storageBuffers, *ptr,
+           sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    *ptr += sizeof(VkPipelineRobustnessBufferBehaviorEXT);
+    memcpy((VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->uniformBuffers, *ptr,
+           sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    *ptr += sizeof(VkPipelineRobustnessBufferBehaviorEXT);
+    memcpy((VkPipelineRobustnessBufferBehaviorEXT*)&forUnmarshaling->vertexInputs, *ptr,
+           sizeof(VkPipelineRobustnessBufferBehaviorEXT));
+    *ptr += sizeof(VkPipelineRobustnessBufferBehaviorEXT);
+    memcpy((VkPipelineRobustnessImageBehaviorEXT*)&forUnmarshaling->images, *ptr,
+           sizeof(VkPipelineRobustnessImageBehaviorEXT));
+    *ptr += sizeof(VkPipelineRobustnessImageBehaviorEXT);
 }
 
 #endif
@@ -16376,18 +18066,12 @@ void reservedunmarshal_VkPipelineViewportSwizzleStateCreateInfoNV(
     *ptr += sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV);
     memcpy((uint32_t*)&forUnmarshaling->viewportCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    // WARNING PTR CHECK
-    memcpy((VkViewportSwizzleNV**)&forUnmarshaling->pViewportSwizzles, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pViewportSwizzles);
-    *ptr += 8;
-    if (forUnmarshaling->pViewportSwizzles) {
-        vkStream->alloc((void**)&forUnmarshaling->pViewportSwizzles,
-                        forUnmarshaling->viewportCount * sizeof(const VkViewportSwizzleNV));
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i) {
-            reservedunmarshal_VkViewportSwizzleNV(
-                vkStream, rootType, (VkViewportSwizzleNV*)(forUnmarshaling->pViewportSwizzles + i),
-                ptr);
-        }
+    vkStream->alloc((void**)&forUnmarshaling->pViewportSwizzles,
+                    forUnmarshaling->viewportCount * sizeof(const VkViewportSwizzleNV));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->viewportCount; ++i) {
+        reservedunmarshal_VkViewportSwizzleNV(
+            vkStream, rootType, (VkViewportSwizzleNV*)(forUnmarshaling->pViewportSwizzles + i),
+            ptr);
     }
 }
 
@@ -16755,8 +18439,6 @@ void reservedunmarshal_VkMacOSSurfaceCreateInfoMVK(VulkanStream* vkStream, VkStr
 }
 
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -16878,48 +18560,28 @@ void reservedunmarshal_VkDebugUtilsMessengerCallbackDataEXT(
     vkStream->loadStringInPlaceWithStreamPtr((char**)&forUnmarshaling->pMessage, ptr);
     memcpy((uint32_t*)&forUnmarshaling->queueLabelCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    // WARNING PTR CHECK
-    memcpy((VkDebugUtilsLabelEXT**)&forUnmarshaling->pQueueLabels, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pQueueLabels);
-    *ptr += 8;
-    if (forUnmarshaling->pQueueLabels) {
-        vkStream->alloc((void**)&forUnmarshaling->pQueueLabels,
-                        forUnmarshaling->queueLabelCount * sizeof(VkDebugUtilsLabelEXT));
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueLabelCount; ++i) {
-            reservedunmarshal_VkDebugUtilsLabelEXT(
-                vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pQueueLabels + i),
-                ptr);
-        }
+    vkStream->alloc((void**)&forUnmarshaling->pQueueLabels,
+                    forUnmarshaling->queueLabelCount * sizeof(const VkDebugUtilsLabelEXT));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueLabelCount; ++i) {
+        reservedunmarshal_VkDebugUtilsLabelEXT(
+            vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pQueueLabels + i), ptr);
     }
     memcpy((uint32_t*)&forUnmarshaling->cmdBufLabelCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    // WARNING PTR CHECK
-    memcpy((VkDebugUtilsLabelEXT**)&forUnmarshaling->pCmdBufLabels, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pCmdBufLabels);
-    *ptr += 8;
-    if (forUnmarshaling->pCmdBufLabels) {
-        vkStream->alloc((void**)&forUnmarshaling->pCmdBufLabels,
-                        forUnmarshaling->cmdBufLabelCount * sizeof(VkDebugUtilsLabelEXT));
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->cmdBufLabelCount; ++i) {
-            reservedunmarshal_VkDebugUtilsLabelEXT(
-                vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pCmdBufLabels + i),
-                ptr);
-        }
+    vkStream->alloc((void**)&forUnmarshaling->pCmdBufLabels,
+                    forUnmarshaling->cmdBufLabelCount * sizeof(const VkDebugUtilsLabelEXT));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->cmdBufLabelCount; ++i) {
+        reservedunmarshal_VkDebugUtilsLabelEXT(
+            vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pCmdBufLabels + i), ptr);
     }
     memcpy((uint32_t*)&forUnmarshaling->objectCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    // WARNING PTR CHECK
-    memcpy((VkDebugUtilsObjectNameInfoEXT**)&forUnmarshaling->pObjects, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pObjects);
-    *ptr += 8;
-    if (forUnmarshaling->pObjects) {
-        vkStream->alloc((void**)&forUnmarshaling->pObjects,
-                        forUnmarshaling->objectCount * sizeof(VkDebugUtilsObjectNameInfoEXT));
-        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->objectCount; ++i) {
-            reservedunmarshal_VkDebugUtilsObjectNameInfoEXT(
-                vkStream, rootType, (VkDebugUtilsObjectNameInfoEXT*)(forUnmarshaling->pObjects + i),
-                ptr);
-        }
+    vkStream->alloc((void**)&forUnmarshaling->pObjects,
+                    forUnmarshaling->objectCount * sizeof(const VkDebugUtilsObjectNameInfoEXT));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->objectCount; ++i) {
+        reservedunmarshal_VkDebugUtilsObjectNameInfoEXT(
+            vkStream, rootType, (VkDebugUtilsObjectNameInfoEXT*)(forUnmarshaling->pObjects + i),
+            ptr);
     }
 }
 
@@ -17243,9 +18905,9 @@ void reservedunmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
     *ptr += sizeof(VkFormat);
     memcpy((uint64_t*)&forUnmarshaling->externalFormat, *ptr, sizeof(uint64_t));
     *ptr += sizeof(uint64_t);
-    memcpy((VkFormatFeatureFlags2KHR*)&forUnmarshaling->formatFeatures, *ptr,
-           sizeof(VkFormatFeatureFlags2KHR));
-    *ptr += sizeof(VkFormatFeatureFlags2KHR);
+    memcpy((VkFormatFeatureFlags2*)&forUnmarshaling->formatFeatures, *ptr,
+           sizeof(VkFormatFeatureFlags2));
+    *ptr += sizeof(VkFormatFeatureFlags2);
     reservedunmarshal_VkComponentMapping(
         vkStream, rootType,
         (VkComponentMapping*)(&forUnmarshaling->samplerYcbcrConversionComponents), ptr);
@@ -17273,141 +18935,6 @@ void reservedunmarshal_VkAndroidHardwareBufferFormatProperties2ANDROID(
 #ifdef VK_AMD_shader_fragment_mask
 #endif
 #ifdef VK_EXT_inline_uniform_block
-void reservedunmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((VkBool32*)&forUnmarshaling->inlineUniformBlock, *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->descriptorBindingInlineUniformBlockUpdateAfterBind, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-}
-
-void reservedunmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->maxInlineUniformBlockSize, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->maxPerStageDescriptorInlineUniformBlocks, *ptr,
-           sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks,
-           *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->maxDescriptorSetInlineUniformBlocks, *ptr,
-           sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->maxDescriptorSetUpdateAfterBindInlineUniformBlocks, *ptr,
-           sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-}
-
-void reservedunmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkWriteDescriptorSetInlineUniformBlockEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->dataSize, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pData,
-                    forUnmarshaling->dataSize * sizeof(const uint8_t));
-    memcpy((void*)forUnmarshaling->pData, *ptr, forUnmarshaling->dataSize * sizeof(const uint8_t));
-    *ptr += forUnmarshaling->dataSize * sizeof(const uint8_t);
-}
-
-void reservedunmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->maxInlineUniformBlockBindings, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-}
-
 #endif
 #ifdef VK_EXT_shader_stencil_export
 #endif
@@ -18099,9 +19626,9 @@ void reservedunmarshal_VkDrmFormatModifierProperties2EXT(
     *ptr += sizeof(uint64_t);
     memcpy((uint32_t*)&forUnmarshaling->drmFormatModifierPlaneCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
-    memcpy((VkFormatFeatureFlags2KHR*)&forUnmarshaling->drmFormatModifierTilingFeatures, *ptr,
-           sizeof(VkFormatFeatureFlags2KHR));
-    *ptr += sizeof(VkFormatFeatureFlags2KHR);
+    memcpy((VkFormatFeatureFlags2*)&forUnmarshaling->drmFormatModifierTilingFeatures, *ptr,
+           sizeof(VkFormatFeatureFlags2));
+    *ptr += sizeof(VkFormatFeatureFlags2);
 }
 
 void reservedunmarshal_VkDrmFormatModifierPropertiesList2EXT(
@@ -19077,36 +20604,6 @@ void reservedunmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
 #ifdef VK_QCOM_render_pass_shader_resolve
 #endif
 #ifdef VK_EXT_global_priority
-void reservedunmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((VkQueueGlobalPriorityEXT*)&forUnmarshaling->globalPriority, *ptr,
-           sizeof(VkQueueGlobalPriorityEXT));
-    *ptr += sizeof(VkQueueGlobalPriorityEXT);
-}
-
 #endif
 #ifdef VK_EXT_external_memory_host
 void reservedunmarshal_VkImportMemoryHostPointerInfoEXT(
@@ -19331,273 +20828,6 @@ void reservedunmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
 }
 
 #endif
-#ifdef VK_EXT_video_decode_h265
-void reservedunmarshal_VkVideoDecodeH265ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                   VkVideoDecodeH265ProfileEXT* forUnmarshaling,
-                                                   uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((StdVideoH265ProfileIdc*)&forUnmarshaling->stdProfileIdc, *ptr,
-           sizeof(StdVideoH265ProfileIdc));
-    *ptr += sizeof(StdVideoH265ProfileIdc);
-}
-
-void reservedunmarshal_VkVideoDecodeH265CapabilitiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265CapabilitiesEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->maxLevel, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    reservedunmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(&forUnmarshaling->stdExtensionVersion), ptr);
-}
-
-void reservedunmarshal_VkVideoDecodeH265SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265SessionCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((VkVideoDecodeH265CreateFlagsEXT*)&forUnmarshaling->flags, *ptr,
-           sizeof(VkVideoDecodeH265CreateFlagsEXT));
-    *ptr += sizeof(VkVideoDecodeH265CreateFlagsEXT);
-    vkStream->alloc((void**)&forUnmarshaling->pStdExtensionVersion,
-                    sizeof(const VkExtensionProperties));
-    reservedunmarshal_VkExtensionProperties(
-        vkStream, rootType, (VkExtensionProperties*)(forUnmarshaling->pStdExtensionVersion), ptr);
-}
-
-void reservedunmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265SessionParametersAddInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->spsStdCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    // WARNING PTR CHECK
-    memcpy((StdVideoH265SequenceParameterSet**)&forUnmarshaling->pSpsStd, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pSpsStd);
-    *ptr += 8;
-    if (forUnmarshaling->pSpsStd) {
-        vkStream->alloc(
-            (void**)&forUnmarshaling->pSpsStd,
-            forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
-        memcpy((StdVideoH265SequenceParameterSet*)forUnmarshaling->pSpsStd, *ptr,
-               forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet));
-        *ptr += forUnmarshaling->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->ppsStdCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    // WARNING PTR CHECK
-    memcpy((StdVideoH265PictureParameterSet**)&forUnmarshaling->pPpsStd, (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pPpsStd);
-    *ptr += 8;
-    if (forUnmarshaling->pPpsStd) {
-        vkStream->alloc(
-            (void**)&forUnmarshaling->pPpsStd,
-            forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
-        memcpy((StdVideoH265PictureParameterSet*)forUnmarshaling->pPpsStd, *ptr,
-               forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet));
-        *ptr += forUnmarshaling->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet);
-    }
-}
-
-void reservedunmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265SessionParametersCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->maxSpsStdCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->maxPpsStdCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    // WARNING PTR CHECK
-    memcpy((VkVideoDecodeH265SessionParametersAddInfoEXT**)&forUnmarshaling->pParametersAddInfo,
-           (*ptr), 8);
-    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pParametersAddInfo);
-    *ptr += 8;
-    if (forUnmarshaling->pParametersAddInfo) {
-        vkStream->alloc((void**)&forUnmarshaling->pParametersAddInfo,
-                        sizeof(const VkVideoDecodeH265SessionParametersAddInfoEXT));
-        reservedunmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
-            vkStream, rootType,
-            (VkVideoDecodeH265SessionParametersAddInfoEXT*)(forUnmarshaling->pParametersAddInfo),
-            ptr);
-    }
-}
-
-void reservedunmarshal_VkVideoDecodeH265PictureInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265PictureInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pStdPictureInfo,
-                    sizeof(StdVideoDecodeH265PictureInfo));
-    memcpy((StdVideoDecodeH265PictureInfo*)forUnmarshaling->pStdPictureInfo, *ptr,
-           sizeof(StdVideoDecodeH265PictureInfo));
-    *ptr += sizeof(StdVideoDecodeH265PictureInfo);
-    memcpy((uint32_t*)&forUnmarshaling->slicesCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pSlicesDataOffsets,
-                    forUnmarshaling->slicesCount * sizeof(const uint32_t));
-    memcpy((uint32_t*)forUnmarshaling->pSlicesDataOffsets, *ptr,
-           forUnmarshaling->slicesCount * sizeof(const uint32_t));
-    *ptr += forUnmarshaling->slicesCount * sizeof(const uint32_t);
-}
-
-void reservedunmarshal_VkVideoDecodeH265DpbSlotInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265DpbSlotInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pStdReferenceInfo,
-                    sizeof(const StdVideoDecodeH265ReferenceInfo));
-    memcpy((StdVideoDecodeH265ReferenceInfo*)forUnmarshaling->pStdReferenceInfo, *ptr,
-           sizeof(const StdVideoDecodeH265ReferenceInfo));
-    *ptr += sizeof(const StdVideoDecodeH265ReferenceInfo);
-}
-
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 void reservedunmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -19773,60 +21003,6 @@ void reservedunmarshal_VkPresentFrameTokenGGP(VulkanStream* vkStream, VkStructur
 
 #endif
 #ifdef VK_EXT_pipeline_creation_feedback
-void reservedunmarshal_VkPipelineCreationFeedbackEXT(VulkanStream* vkStream,
-                                                     VkStructureType rootType,
-                                                     VkPipelineCreationFeedbackEXT* forUnmarshaling,
-                                                     uint8_t** ptr) {
-    memcpy((VkPipelineCreationFeedbackFlagsEXT*)&forUnmarshaling->flags, *ptr,
-           sizeof(VkPipelineCreationFeedbackFlagsEXT));
-    *ptr += sizeof(VkPipelineCreationFeedbackFlagsEXT);
-    memcpy((uint64_t*)&forUnmarshaling->duration, *ptr, sizeof(uint64_t));
-    *ptr += sizeof(uint64_t);
-}
-
-void reservedunmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPipelineCreationFeedbackCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    vkStream->alloc((void**)&forUnmarshaling->pPipelineCreationFeedback,
-                    sizeof(VkPipelineCreationFeedbackEXT));
-    reservedunmarshal_VkPipelineCreationFeedbackEXT(
-        vkStream, rootType,
-        (VkPipelineCreationFeedbackEXT*)(forUnmarshaling->pPipelineCreationFeedback), ptr);
-    memcpy((uint32_t*)&forUnmarshaling->pipelineStageCreationFeedbackCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    vkStream->alloc((void**)&forUnmarshaling->pPipelineStageCreationFeedbacks,
-                    forUnmarshaling->pipelineStageCreationFeedbackCount *
-                        sizeof(VkPipelineCreationFeedbackEXT));
-    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pipelineStageCreationFeedbackCount; ++i) {
-        reservedunmarshal_VkPipelineCreationFeedbackEXT(
-            vkStream, rootType,
-            (VkPipelineCreationFeedbackEXT*)(forUnmarshaling->pPipelineStageCreationFeedbacks + i),
-            ptr);
-    }
-}
-
 #endif
 #ifdef VK_NV_shader_subgroup_partitioned
 #endif
@@ -19959,35 +21135,6 @@ void reservedunmarshal_VkDrawMeshTasksIndirectCommandNV(
 
 #endif
 #ifdef VK_NV_fragment_shader_barycentric
-void reservedunmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((VkBool32*)&forUnmarshaling->fragmentShaderBarycentric, *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-}
-
 #endif
 #ifdef VK_NV_shader_image_footprint
 void reservedunmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -20650,102 +21797,6 @@ void reservedunmarshal_VkRenderPassFragmentDensityMapCreateInfoEXT(
 #ifdef VK_GOOGLE_decorate_string
 #endif
 #ifdef VK_EXT_subgroup_size_control
-void reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((VkBool32*)&forUnmarshaling->subgroupSizeControl, *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkBool32*)&forUnmarshaling->computeFullSubgroups, *ptr, sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-}
-
-void reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->minSubgroupSize, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->maxSubgroupSize, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((uint32_t*)&forUnmarshaling->maxComputeWorkgroupSubgroups, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((VkShaderStageFlags*)&forUnmarshaling->requiredSubgroupSizeStages, *ptr,
-           sizeof(VkShaderStageFlags));
-    *ptr += sizeof(VkShaderStageFlags);
-}
-
-void reservedunmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((uint32_t*)&forUnmarshaling->requiredSubgroupSize, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-}
-
 #endif
 #ifdef VK_AMD_shader_core_properties2
 void reservedunmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -21036,43 +22087,6 @@ void reservedunmarshal_VkBufferDeviceAddressCreateInfoEXT(
 
 #endif
 #ifdef VK_EXT_tooling_info
-void reservedunmarshal_VkPhysicalDeviceToolPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceToolPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((char*)forUnmarshaling->name, *ptr, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-    *ptr += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
-    memcpy((char*)forUnmarshaling->version, *ptr, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-    *ptr += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
-    memcpy((VkToolPurposeFlagsEXT*)&forUnmarshaling->purposes, *ptr, sizeof(VkToolPurposeFlagsEXT));
-    *ptr += sizeof(VkToolPurposeFlagsEXT);
-    memcpy((char*)forUnmarshaling->description, *ptr, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
-    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
-    memcpy((char*)forUnmarshaling->layer, *ptr, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char));
-    *ptr += VK_MAX_EXTENSION_NAME_SIZE * sizeof(char);
-}
-
 #endif
 #ifdef VK_EXT_separate_stencil_usage
 #endif
@@ -21894,10 +22908,39 @@ void reservedunmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
 }
 
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-void reservedunmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+void reservedunmarshal_VkSurfacePresentModeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkSurfacePresentModeEXT* forUnmarshaling,
+                                               uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkPresentModeKHR*)&forUnmarshaling->presentMode, *ptr, sizeof(VkPresentModeKHR));
+    *ptr += sizeof(VkPresentModeKHR);
+}
+
+void reservedunmarshal_VkSurfacePresentScalingCapabilitiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    VkSurfacePresentScalingCapabilitiesEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -21920,10 +22963,281 @@ void reservedunmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->shaderDemoteToHelperInvocation, *ptr, sizeof(VkBool32));
+    memcpy((VkPresentScalingFlagsEXT*)&forUnmarshaling->supportedPresentScaling, *ptr,
+           sizeof(VkPresentScalingFlagsEXT));
+    *ptr += sizeof(VkPresentScalingFlagsEXT);
+    memcpy((VkPresentGravityFlagsEXT*)&forUnmarshaling->supportedPresentGravityX, *ptr,
+           sizeof(VkPresentGravityFlagsEXT));
+    *ptr += sizeof(VkPresentGravityFlagsEXT);
+    memcpy((VkPresentGravityFlagsEXT*)&forUnmarshaling->supportedPresentGravityY, *ptr,
+           sizeof(VkPresentGravityFlagsEXT));
+    *ptr += sizeof(VkPresentGravityFlagsEXT);
+    reservedunmarshal_VkExtent2D(vkStream, rootType,
+                                 (VkExtent2D*)(&forUnmarshaling->minScaledImageExtent), ptr);
+    reservedunmarshal_VkExtent2D(vkStream, rootType,
+                                 (VkExtent2D*)(&forUnmarshaling->maxScaledImageExtent), ptr);
+}
+
+void reservedunmarshal_VkSurfacePresentModeCompatibilityEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSurfacePresentModeCompatibilityEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->presentModeCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    // WARNING PTR CHECK
+    memcpy((VkPresentModeKHR**)&forUnmarshaling->pPresentModes, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pPresentModes);
+    *ptr += 8;
+    if (forUnmarshaling->pPresentModes) {
+        vkStream->alloc((void**)&forUnmarshaling->pPresentModes,
+                        forUnmarshaling->presentModeCount * sizeof(VkPresentModeKHR));
+        memcpy((VkPresentModeKHR*)forUnmarshaling->pPresentModes, *ptr,
+               forUnmarshaling->presentModeCount * sizeof(VkPresentModeKHR));
+        *ptr += forUnmarshaling->presentModeCount * sizeof(VkPresentModeKHR);
+    }
+}
+
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+void reservedunmarshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->swapchainMaintenance1, *ptr, sizeof(VkBool32));
     *ptr += sizeof(VkBool32);
 }
 
+void reservedunmarshal_VkSwapchainPresentFenceInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainPresentFenceInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->swapchainCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pFences,
+                    forUnmarshaling->swapchainCount * sizeof(const VkFence));
+    if (forUnmarshaling->swapchainCount) {
+        uint8_t* cgen_var_0_ptr = (uint8_t*)(*ptr);
+        *ptr += 8 * forUnmarshaling->swapchainCount;
+        if (forUnmarshaling) {
+            for (uint32_t k = 0; k < forUnmarshaling->swapchainCount; ++k) {
+                uint64_t tmpval;
+                memcpy(&tmpval, cgen_var_0_ptr + k * 8, sizeof(uint64_t));
+                *(((VkFence*)forUnmarshaling->pFences) + k) =
+                    (VkFence)unbox_VkFence((VkFence)tmpval);
+            }
+        }
+    }
+}
+
+void reservedunmarshal_VkSwapchainPresentModesCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainPresentModesCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->presentModeCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pPresentModes,
+                    forUnmarshaling->presentModeCount * sizeof(const VkPresentModeKHR));
+    memcpy((VkPresentModeKHR*)forUnmarshaling->pPresentModes, *ptr,
+           forUnmarshaling->presentModeCount * sizeof(const VkPresentModeKHR));
+    *ptr += forUnmarshaling->presentModeCount * sizeof(const VkPresentModeKHR);
+}
+
+void reservedunmarshal_VkSwapchainPresentModeInfoEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkSwapchainPresentModeInfoEXT* forUnmarshaling,
+                                                     uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->swapchainCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pPresentModes,
+                    forUnmarshaling->swapchainCount * sizeof(const VkPresentModeKHR));
+    memcpy((VkPresentModeKHR*)forUnmarshaling->pPresentModes, *ptr,
+           forUnmarshaling->swapchainCount * sizeof(const VkPresentModeKHR));
+    *ptr += forUnmarshaling->swapchainCount * sizeof(const VkPresentModeKHR);
+}
+
+void reservedunmarshal_VkSwapchainPresentScalingCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainPresentScalingCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkPresentScalingFlagsEXT*)&forUnmarshaling->scalingBehavior, *ptr,
+           sizeof(VkPresentScalingFlagsEXT));
+    *ptr += sizeof(VkPresentScalingFlagsEXT);
+    memcpy((VkPresentGravityFlagsEXT*)&forUnmarshaling->presentGravityX, *ptr,
+           sizeof(VkPresentGravityFlagsEXT));
+    *ptr += sizeof(VkPresentGravityFlagsEXT);
+    memcpy((VkPresentGravityFlagsEXT*)&forUnmarshaling->presentGravityY, *ptr,
+           sizeof(VkPresentGravityFlagsEXT));
+    *ptr += sizeof(VkPresentGravityFlagsEXT);
+}
+
+void reservedunmarshal_VkReleaseSwapchainImagesInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkReleaseSwapchainImagesInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkSwapchainKHR*)&forUnmarshaling->swapchain =
+        (VkSwapchainKHR)unbox_VkSwapchainKHR((VkSwapchainKHR)(*&cgen_var_0));
+    memcpy((uint32_t*)&forUnmarshaling->imageIndexCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pImageIndices,
+                    forUnmarshaling->imageIndexCount * sizeof(const uint32_t));
+    memcpy((uint32_t*)forUnmarshaling->pImageIndices, *ptr,
+           forUnmarshaling->imageIndexCount * sizeof(const uint32_t));
+    *ptr += forUnmarshaling->imageIndexCount * sizeof(const uint32_t);
+}
+
+#endif
+#ifdef VK_EXT_shader_demote_to_helper_invocation
 #endif
 #ifdef VK_NV_device_generated_commands
 void reservedunmarshal_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
@@ -22494,45 +23808,6 @@ void reservedunmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
     *ptr += sizeof(VkBool32);
 }
 
-void reservedunmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
-    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
-    *ptr += sizeof(VkStructureType);
-    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
-        rootType = forUnmarshaling->sType;
-    }
-    uint32_t pNext_size;
-    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
-    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
-    *ptr += sizeof(uint32_t);
-    forUnmarshaling->pNext = nullptr;
-    if (pNext_size) {
-        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
-        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
-        *ptr += sizeof(VkStructureType);
-        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
-        vkStream->alloc((void**)&forUnmarshaling->pNext,
-                        goldfish_vk_extension_struct_size_with_stream_features(
-                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
-        *(VkStructureType*)forUnmarshaling->pNext = extType;
-        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
-                                           ptr);
-    }
-    memcpy((VkDeviceSize*)&forUnmarshaling->storageTexelBufferOffsetAlignmentBytes, *ptr,
-           sizeof(VkDeviceSize));
-    *ptr += sizeof(VkDeviceSize);
-    memcpy((VkBool32*)&forUnmarshaling->storageTexelBufferOffsetSingleTexelAlignment, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-    memcpy((VkDeviceSize*)&forUnmarshaling->uniformTexelBufferOffsetAlignmentBytes, *ptr,
-           sizeof(VkDeviceSize));
-    *ptr += sizeof(VkDeviceSize);
-    memcpy((VkBool32*)&forUnmarshaling->uniformTexelBufferOffsetSingleTexelAlignment, *ptr,
-           sizeof(VkBool32));
-    *ptr += sizeof(VkBool32);
-}
-
 #endif
 #ifdef VK_QCOM_render_pass_transform
 void reservedunmarshal_VkRenderPassTransformBeginInfoQCOM(
@@ -22872,10 +24147,103 @@ void reservedunmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+void reservedunmarshal_VkPhysicalDevicePresentBarrierFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePresentBarrierFeaturesNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->presentBarrier, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkSurfaceCapabilitiesPresentBarrierNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSurfaceCapabilitiesPresentBarrierNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->presentBarrierSupported, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkSwapchainPresentBarrierCreateInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainPresentBarrierCreateInfoNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->presentBarrierEnable, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
 #ifdef VK_EXT_private_data
-void reservedunmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
+#endif
+#ifdef VK_EXT_pipeline_creation_cache_control
+#endif
+#ifdef VK_NV_device_diagnostics_config
+void reservedunmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDevicePrivateDataFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -22898,13 +24266,13 @@ void reservedunmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->privateData, *ptr, sizeof(VkBool32));
+    memcpy((VkBool32*)&forUnmarshaling->diagnosticsConfig, *ptr, sizeof(VkBool32));
     *ptr += sizeof(VkBool32);
 }
 
-void reservedunmarshal_VkDevicePrivateDataCreateInfoEXT(
+void reservedunmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkDevicePrivateDataCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    VkDeviceDiagnosticsConfigCreateInfoNV* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -22927,13 +24295,136 @@ void reservedunmarshal_VkDevicePrivateDataCreateInfoEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((uint32_t*)&forUnmarshaling->privateDataSlotRequestCount, *ptr, sizeof(uint32_t));
+    memcpy((VkDeviceDiagnosticsConfigFlagsNV*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkDeviceDiagnosticsConfigFlagsNV));
+    *ptr += sizeof(VkDeviceDiagnosticsConfigFlagsNV);
+}
+
+#endif
+#ifdef VK_QCOM_render_pass_store_ops
+#endif
+#ifdef VK_NV_low_latency
+void reservedunmarshal_VkQueryLowLatencySupportNV(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkQueryLowLatencySupportNV* forUnmarshaling,
+                                                  uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pQueriedLowLatencyData, sizeof(uint8_t));
+    memcpy((void*)forUnmarshaling->pQueriedLowLatencyData, *ptr, sizeof(uint8_t));
+    *ptr += sizeof(uint8_t);
+}
+
+#endif
+#ifdef VK_EXT_metal_objects
+void reservedunmarshal_VkExportMetalObjectCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkExportMetalObjectCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkExportMetalObjectTypeFlagBitsEXT*)&forUnmarshaling->exportObjectType, *ptr,
+           sizeof(VkExportMetalObjectTypeFlagBitsEXT));
+    *ptr += sizeof(VkExportMetalObjectTypeFlagBitsEXT);
+}
+
+void reservedunmarshal_VkExportMetalObjectsInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkExportMetalObjectsInfoEXT* forUnmarshaling,
+                                                   uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
     *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
 }
 
-void reservedunmarshal_VkPrivateDataSlotCreateInfoEXT(
+void reservedunmarshal_VkExportMetalDeviceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkExportMetalDeviceInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((MTLDevice_id*)&forUnmarshaling->mtlDevice, *ptr, sizeof(MTLDevice_id));
+    *ptr += sizeof(MTLDevice_id);
+}
+
+void reservedunmarshal_VkExportMetalCommandQueueInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPrivateDataSlotCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    VkExportMetalCommandQueueInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -22956,16 +24447,290 @@ void reservedunmarshal_VkPrivateDataSlotCreateInfoEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkPrivateDataSlotCreateFlagsEXT*)&forUnmarshaling->flags, *ptr,
-           sizeof(VkPrivateDataSlotCreateFlagsEXT));
-    *ptr += sizeof(VkPrivateDataSlotCreateFlagsEXT);
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkQueue*)&forUnmarshaling->queue = (VkQueue)unbox_VkQueue((VkQueue)(*&cgen_var_0));
+    memcpy((MTLCommandQueue_id*)&forUnmarshaling->mtlCommandQueue, *ptr,
+           sizeof(MTLCommandQueue_id));
+    *ptr += sizeof(MTLCommandQueue_id);
+}
+
+void reservedunmarshal_VkExportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkExportMetalBufferInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkDeviceMemory*)&forUnmarshaling->memory =
+        (VkDeviceMemory)unbox_VkDeviceMemory((VkDeviceMemory)(*&cgen_var_0));
+    memcpy((MTLBuffer_id*)&forUnmarshaling->mtlBuffer, *ptr, sizeof(MTLBuffer_id));
+    *ptr += sizeof(MTLBuffer_id);
+}
+
+void reservedunmarshal_VkImportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkImportMetalBufferInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((MTLBuffer_id*)&forUnmarshaling->mtlBuffer, *ptr, sizeof(MTLBuffer_id));
+    *ptr += sizeof(MTLBuffer_id);
+}
+
+void reservedunmarshal_VkExportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkExportMetalTextureInfoEXT* forUnmarshaling,
+                                                   uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+    uint64_t cgen_var_1;
+    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImageView*)&forUnmarshaling->imageView =
+        (VkImageView)unbox_VkImageView((VkImageView)(*&cgen_var_1));
+    uint64_t cgen_var_2;
+    memcpy((uint64_t*)&cgen_var_2, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkBufferView*)&forUnmarshaling->bufferView =
+        (VkBufferView)unbox_VkBufferView((VkBufferView)(*&cgen_var_2));
+    memcpy((VkImageAspectFlagBits*)&forUnmarshaling->plane, *ptr, sizeof(VkImageAspectFlagBits));
+    *ptr += sizeof(VkImageAspectFlagBits);
+    memcpy((MTLTexture_id*)&forUnmarshaling->mtlTexture, *ptr, sizeof(MTLTexture_id));
+    *ptr += sizeof(MTLTexture_id);
+}
+
+void reservedunmarshal_VkImportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkImportMetalTextureInfoEXT* forUnmarshaling,
+                                                   uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkImageAspectFlagBits*)&forUnmarshaling->plane, *ptr, sizeof(VkImageAspectFlagBits));
+    *ptr += sizeof(VkImageAspectFlagBits);
+    memcpy((MTLTexture_id*)&forUnmarshaling->mtlTexture, *ptr, sizeof(MTLTexture_id));
+    *ptr += sizeof(MTLTexture_id);
+}
+
+void reservedunmarshal_VkExportMetalIOSurfaceInfoEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkExportMetalIOSurfaceInfoEXT* forUnmarshaling,
+                                                     uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+    memcpy((IOSurfaceRef*)&forUnmarshaling->ioSurface, *ptr, sizeof(IOSurfaceRef));
+    *ptr += sizeof(IOSurfaceRef);
+}
+
+void reservedunmarshal_VkImportMetalIOSurfaceInfoEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkImportMetalIOSurfaceInfoEXT* forUnmarshaling,
+                                                     uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((IOSurfaceRef*)&forUnmarshaling->ioSurface, *ptr, sizeof(IOSurfaceRef));
+    *ptr += sizeof(IOSurfaceRef);
+}
+
+void reservedunmarshal_VkExportMetalSharedEventInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkExportMetalSharedEventInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkSemaphore*)&forUnmarshaling->semaphore =
+        (VkSemaphore)unbox_VkSemaphore((VkSemaphore)(*&cgen_var_0));
+    uint64_t cgen_var_1;
+    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkEvent*)&forUnmarshaling->event = (VkEvent)unbox_VkEvent((VkEvent)(*&cgen_var_1));
+    memcpy((MTLSharedEvent_id*)&forUnmarshaling->mtlSharedEvent, *ptr, sizeof(MTLSharedEvent_id));
+    *ptr += sizeof(MTLSharedEvent_id);
+}
+
+void reservedunmarshal_VkImportMetalSharedEventInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImportMetalSharedEventInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((MTLSharedEvent_id*)&forUnmarshaling->mtlSharedEvent, *ptr, sizeof(MTLSharedEvent_id));
+    *ptr += sizeof(MTLSharedEvent_id);
 }
 
 #endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-void reservedunmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+#ifdef VK_EXT_descriptor_buffer
+void reservedunmarshal_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -22988,15 +24753,512 @@ void reservedunmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->pipelineCreationCacheControl, *ptr, sizeof(VkBool32));
+    memcpy((VkBool32*)&forUnmarshaling->combinedImageSamplerDescriptorSingleArray, *ptr,
+           sizeof(VkBool32));
     *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->bufferlessPushDescriptors, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->allowSamplerImageViewPostSubmitCreation, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkDeviceSize*)&forUnmarshaling->descriptorBufferOffsetAlignment, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((uint32_t*)&forUnmarshaling->maxDescriptorBufferBindings, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxResourceDescriptorBufferBindings, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxSamplerDescriptorBufferBindings, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxEmbeddedImmutableSamplerBindings, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxEmbeddedImmutableSamplers, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((size_t*)&forUnmarshaling->bufferCaptureReplayDescriptorDataSize, (*ptr), 8);
+    android::base::Stream::fromBe64(
+        (uint8_t*)&forUnmarshaling->bufferCaptureReplayDescriptorDataSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->imageCaptureReplayDescriptorDataSize, (*ptr), 8);
+    android::base::Stream::fromBe64(
+        (uint8_t*)&forUnmarshaling->imageCaptureReplayDescriptorDataSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->imageViewCaptureReplayDescriptorDataSize, (*ptr), 8);
+    android::base::Stream::fromBe64(
+        (uint8_t*)&forUnmarshaling->imageViewCaptureReplayDescriptorDataSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->samplerCaptureReplayDescriptorDataSize, (*ptr), 8);
+    android::base::Stream::fromBe64(
+        (uint8_t*)&forUnmarshaling->samplerCaptureReplayDescriptorDataSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->accelerationStructureCaptureReplayDescriptorDataSize, (*ptr),
+           8);
+    android::base::Stream::fromBe64(
+        (uint8_t*)&forUnmarshaling->accelerationStructureCaptureReplayDescriptorDataSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->samplerDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->samplerDescriptorSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->combinedImageSamplerDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->combinedImageSamplerDescriptorSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->sampledImageDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->sampledImageDescriptorSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->storageImageDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->storageImageDescriptorSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->uniformTexelBufferDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->uniformTexelBufferDescriptorSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->robustUniformTexelBufferDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64(
+        (uint8_t*)&forUnmarshaling->robustUniformTexelBufferDescriptorSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->storageTexelBufferDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->storageTexelBufferDescriptorSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->robustStorageTexelBufferDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64(
+        (uint8_t*)&forUnmarshaling->robustStorageTexelBufferDescriptorSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->uniformBufferDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->uniformBufferDescriptorSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->robustUniformBufferDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->robustUniformBufferDescriptorSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->storageBufferDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->storageBufferDescriptorSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->robustStorageBufferDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->robustStorageBufferDescriptorSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->inputAttachmentDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->inputAttachmentDescriptorSize);
+    *ptr += 8;
+    memcpy((size_t*)&forUnmarshaling->accelerationStructureDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64(
+        (uint8_t*)&forUnmarshaling->accelerationStructureDescriptorSize);
+    *ptr += 8;
+    memcpy((VkDeviceSize*)&forUnmarshaling->maxSamplerDescriptorBufferRange, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceSize*)&forUnmarshaling->maxResourceDescriptorBufferRange, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceSize*)&forUnmarshaling->samplerDescriptorBufferAddressSpaceSize, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceSize*)&forUnmarshaling->resourceDescriptorBufferAddressSpaceSize, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceSize*)&forUnmarshaling->descriptorBufferAddressSpaceSize, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+}
+
+void reservedunmarshal_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((size_t*)&forUnmarshaling->combinedImageSamplerDensityMapDescriptorSize, (*ptr), 8);
+    android::base::Stream::fromBe64(
+        (uint8_t*)&forUnmarshaling->combinedImageSamplerDensityMapDescriptorSize);
+    *ptr += 8;
+}
+
+void reservedunmarshal_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->descriptorBuffer, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->descriptorBufferCaptureReplay, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->descriptorBufferImageLayoutIgnored, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->descriptorBufferPushDescriptors, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkDescriptorAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkDescriptorAddressInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkDeviceAddress*)&forUnmarshaling->address, *ptr, sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+    memcpy((VkDeviceSize*)&forUnmarshaling->range, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkFormat*)&forUnmarshaling->format, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+}
+
+void reservedunmarshal_VkDescriptorBufferBindingInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorBufferBindingInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkDeviceAddress*)&forUnmarshaling->address, *ptr, sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+    memcpy((VkBufferUsageFlags*)&forUnmarshaling->usage, *ptr, sizeof(VkBufferUsageFlags));
+    *ptr += sizeof(VkBufferUsageFlags);
+}
+
+void reservedunmarshal_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkBuffer*)&forUnmarshaling->buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+}
+
+void reservedunmarshal_VkDescriptorDataEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkDescriptorDataEXT* forUnmarshaling, uint8_t** ptr) {
+    vkStream->alloc((void**)&forUnmarshaling->pSampler, sizeof(const VkSampler));
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 8);
+    *ptr += 8;
+    *(VkSampler*)forUnmarshaling->pSampler = (VkSampler)unbox_VkSampler((VkSampler)(*&cgen_var_0));
+}
+
+void reservedunmarshal_VkDescriptorGetInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkDescriptorGetInfoEXT* forUnmarshaling,
+                                              uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkDescriptorType*)&forUnmarshaling->type, *ptr, sizeof(VkDescriptorType));
+    *ptr += sizeof(VkDescriptorType);
+    reservedunmarshal_VkDescriptorDataEXT(vkStream, rootType,
+                                          (VkDescriptorDataEXT*)(&forUnmarshaling->data), ptr);
+}
+
+void reservedunmarshal_VkBufferCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkBufferCaptureDescriptorDataInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkBuffer*)&forUnmarshaling->buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+}
+
+void reservedunmarshal_VkImageCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageCaptureDescriptorDataInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImage*)&forUnmarshaling->image = (VkImage)unbox_VkImage((VkImage)(*&cgen_var_0));
+}
+
+void reservedunmarshal_VkImageViewCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageViewCaptureDescriptorDataInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkImageView*)&forUnmarshaling->imageView =
+        (VkImageView)unbox_VkImageView((VkImageView)(*&cgen_var_0));
+}
+
+void reservedunmarshal_VkSamplerCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSamplerCaptureDescriptorDataInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkSampler*)&forUnmarshaling->sampler = (VkSampler)unbox_VkSampler((VkSampler)(*&cgen_var_0));
+}
+
+void reservedunmarshal_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpaqueCaptureDescriptorDataCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->opaqueCaptureDescriptorData, sizeof(const uint8_t));
+    memcpy((void*)forUnmarshaling->opaqueCaptureDescriptorData, *ptr, sizeof(const uint8_t));
+    *ptr += sizeof(const uint8_t);
+}
+
+void reservedunmarshal_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkAccelerationStructureKHR*)&forUnmarshaling->accelerationStructure =
+        (VkAccelerationStructureKHR)unbox_VkAccelerationStructureKHR(
+            (VkAccelerationStructureKHR)(*&cgen_var_0));
+    uint64_t cgen_var_1;
+    memcpy((uint64_t*)&cgen_var_1, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkAccelerationStructureNV*)&forUnmarshaling->accelerationStructureNV =
+        (VkAccelerationStructureNV)unbox_VkAccelerationStructureNV(
+            (VkAccelerationStructureNV)(*&cgen_var_1));
 }
 
 #endif
-#ifdef VK_NV_device_diagnostics_config
-void reservedunmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+#ifdef VK_EXT_graphics_pipeline_library
+void reservedunmarshal_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* forUnmarshaling, uint8_t** ptr) {
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -23019,13 +25281,13 @@ void reservedunmarshal_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->diagnosticsConfig, *ptr, sizeof(VkBool32));
+    memcpy((VkBool32*)&forUnmarshaling->graphicsPipelineLibrary, *ptr, sizeof(VkBool32));
     *ptr += sizeof(VkBool32);
 }
 
-void reservedunmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
+void reservedunmarshal_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceDiagnosticsConfigCreateInfoNV* forUnmarshaling, uint8_t** ptr) {
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -23048,13 +25310,74 @@ void reservedunmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkDeviceDiagnosticsConfigFlagsNV*)&forUnmarshaling->flags, *ptr,
-           sizeof(VkDeviceDiagnosticsConfigFlagsNV));
-    *ptr += sizeof(VkDeviceDiagnosticsConfigFlagsNV);
+    memcpy((VkBool32*)&forUnmarshaling->graphicsPipelineLibraryFastLinking, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->graphicsPipelineLibraryIndependentInterpolationDecoration,
+           *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkGraphicsPipelineLibraryCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkGraphicsPipelineLibraryCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkGraphicsPipelineLibraryFlagsEXT*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkGraphicsPipelineLibraryFlagsEXT));
+    *ptr += sizeof(VkGraphicsPipelineLibraryFlagsEXT);
 }
 
 #endif
-#ifdef VK_QCOM_render_pass_store_ops
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+void reservedunmarshal_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->shaderEarlyAndLateFragmentTests, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
 #endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void reservedunmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -23497,9 +25820,11 @@ void reservedunmarshal_VkCopyCommandTransformInfoQCOM(
 
 #endif
 #ifdef VK_EXT_image_robustness
-void reservedunmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+#endif
+#ifdef VK_EXT_image_compression_control
+void reservedunmarshal_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceImageRobustnessFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -23522,7 +25847,176 @@ void reservedunmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->robustImageAccess, *ptr, sizeof(VkBool32));
+    memcpy((VkBool32*)&forUnmarshaling->imageCompressionControl, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkImageCompressionControlEXT(VulkanStream* vkStream,
+                                                    VkStructureType rootType,
+                                                    VkImageCompressionControlEXT* forUnmarshaling,
+                                                    uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkImageCompressionFlagsEXT*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkImageCompressionFlagsEXT));
+    *ptr += sizeof(VkImageCompressionFlagsEXT);
+    memcpy((uint32_t*)&forUnmarshaling->compressionControlPlaneCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    // WARNING PTR CHECK
+    memcpy((VkImageCompressionFixedRateFlagsEXT**)&forUnmarshaling->pFixedRateFlags, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pFixedRateFlags);
+    *ptr += 8;
+    if (forUnmarshaling->pFixedRateFlags) {
+        vkStream->alloc((void**)&forUnmarshaling->pFixedRateFlags,
+                        forUnmarshaling->compressionControlPlaneCount *
+                            sizeof(VkImageCompressionFixedRateFlagsEXT));
+        memcpy((VkImageCompressionFixedRateFlagsEXT*)forUnmarshaling->pFixedRateFlags, *ptr,
+               forUnmarshaling->compressionControlPlaneCount *
+                   sizeof(VkImageCompressionFixedRateFlagsEXT));
+        *ptr += forUnmarshaling->compressionControlPlaneCount *
+                sizeof(VkImageCompressionFixedRateFlagsEXT);
+    }
+}
+
+void reservedunmarshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkSubresourceLayout2EXT* forUnmarshaling,
+                                               uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    reservedunmarshal_VkSubresourceLayout(
+        vkStream, rootType, (VkSubresourceLayout*)(&forUnmarshaling->subresourceLayout), ptr);
+}
+
+void reservedunmarshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkImageSubresource2EXT* forUnmarshaling,
+                                              uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    reservedunmarshal_VkImageSubresource(
+        vkStream, rootType, (VkImageSubresource*)(&forUnmarshaling->imageSubresource), ptr);
+}
+
+void reservedunmarshal_VkImageCompressionPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageCompressionPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkImageCompressionFlagsEXT*)&forUnmarshaling->imageCompressionFlags, *ptr,
+           sizeof(VkImageCompressionFlagsEXT));
+    *ptr += sizeof(VkImageCompressionFlagsEXT);
+    memcpy((VkImageCompressionFixedRateFlagsEXT*)&forUnmarshaling->imageCompressionFixedRateFlags,
+           *ptr, sizeof(VkImageCompressionFixedRateFlagsEXT));
+    *ptr += sizeof(VkImageCompressionFixedRateFlagsEXT);
+}
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+void reservedunmarshal_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->attachmentFeedbackLoopLayout, *ptr, sizeof(VkBool32));
     *ptr += sizeof(VkBool32);
 }
 
@@ -23560,6 +26054,218 @@ void reservedunmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
 }
 
 #endif
+#ifdef VK_EXT_device_fault
+void reservedunmarshal_VkPhysicalDeviceFaultFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFaultFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->deviceFault, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->deviceFaultVendorBinary, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkDeviceFaultCountsEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkDeviceFaultCountsEXT* forUnmarshaling,
+                                              uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->addressInfoCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->vendorInfoCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((VkDeviceSize*)&forUnmarshaling->vendorBinarySize, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+}
+
+void reservedunmarshal_VkDeviceFaultAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkDeviceFaultAddressInfoEXT* forUnmarshaling,
+                                                   uint8_t** ptr) {
+    memcpy((VkDeviceFaultAddressTypeEXT*)&forUnmarshaling->addressType, *ptr,
+           sizeof(VkDeviceFaultAddressTypeEXT));
+    *ptr += sizeof(VkDeviceFaultAddressTypeEXT);
+    memcpy((VkDeviceAddress*)&forUnmarshaling->reportedAddress, *ptr, sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+    memcpy((VkDeviceSize*)&forUnmarshaling->addressPrecision, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+}
+
+void reservedunmarshal_VkDeviceFaultVendorInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkDeviceFaultVendorInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr) {
+    memcpy((char*)forUnmarshaling->description, *ptr, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
+    memcpy((uint64_t*)&forUnmarshaling->vendorFaultCode, *ptr, sizeof(uint64_t));
+    *ptr += sizeof(uint64_t);
+    memcpy((uint64_t*)&forUnmarshaling->vendorFaultData, *ptr, sizeof(uint64_t));
+    *ptr += sizeof(uint64_t);
+}
+
+void reservedunmarshal_VkDeviceFaultInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            VkDeviceFaultInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((char*)forUnmarshaling->description, *ptr, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
+    // WARNING PTR CHECK
+    memcpy((VkDeviceFaultAddressInfoEXT**)&forUnmarshaling->pAddressInfos, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pAddressInfos);
+    *ptr += 8;
+    if (forUnmarshaling->pAddressInfos) {
+        vkStream->alloc((void**)&forUnmarshaling->pAddressInfos,
+                        sizeof(VkDeviceFaultAddressInfoEXT));
+        reservedunmarshal_VkDeviceFaultAddressInfoEXT(
+            vkStream, rootType, (VkDeviceFaultAddressInfoEXT*)(forUnmarshaling->pAddressInfos),
+            ptr);
+    }
+    // WARNING PTR CHECK
+    memcpy((VkDeviceFaultVendorInfoEXT**)&forUnmarshaling->pVendorInfos, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pVendorInfos);
+    *ptr += 8;
+    if (forUnmarshaling->pVendorInfos) {
+        vkStream->alloc((void**)&forUnmarshaling->pVendorInfos, sizeof(VkDeviceFaultVendorInfoEXT));
+        reservedunmarshal_VkDeviceFaultVendorInfoEXT(
+            vkStream, rootType, (VkDeviceFaultVendorInfoEXT*)(forUnmarshaling->pVendorInfos), ptr);
+    }
+    // WARNING PTR CHECK
+    memcpy((void**)&forUnmarshaling->pVendorBinaryData, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pVendorBinaryData);
+    *ptr += 8;
+    if (forUnmarshaling->pVendorBinaryData) {
+        vkStream->alloc((void**)&forUnmarshaling->pVendorBinaryData, sizeof(uint8_t));
+        memcpy((void*)forUnmarshaling->pVendorBinaryData, *ptr, sizeof(uint8_t));
+        *ptr += sizeof(uint8_t);
+    }
+}
+
+void reservedunmarshal_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceFaultVendorBinaryHeaderVersionOneEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((uint32_t*)&forUnmarshaling->headerSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((VkDeviceFaultVendorBinaryHeaderVersionEXT*)&forUnmarshaling->headerVersion, *ptr,
+           sizeof(VkDeviceFaultVendorBinaryHeaderVersionEXT));
+    *ptr += sizeof(VkDeviceFaultVendorBinaryHeaderVersionEXT);
+    memcpy((uint32_t*)&forUnmarshaling->vendorID, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->deviceID, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->driverVersion, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint8_t*)forUnmarshaling->pipelineCacheUUID, *ptr, VK_UUID_SIZE * sizeof(uint8_t));
+    *ptr += VK_UUID_SIZE * sizeof(uint8_t);
+    memcpy((uint32_t*)&forUnmarshaling->applicationNameOffset, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->applicationVersion, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->engineNameOffset, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->engineVersion, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->apiVersion, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+void reservedunmarshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->rasterizationOrderColorAttachmentAccess, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->rasterizationOrderDepthAttachmentAccess, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->rasterizationOrderStencilAttachmentAccess, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 void reservedunmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -23644,9 +26350,9 @@ void reservedunmarshal_VkDirectFBSurfaceCreateInfoEXT(
 
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-void reservedunmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+void reservedunmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forUnmarshaling, uint8_t** ptr) {
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -23673,9 +26379,9 @@ void reservedunmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
     *ptr += sizeof(VkBool32);
 }
 
-void reservedunmarshal_VkMutableDescriptorTypeListVALVE(
+void reservedunmarshal_VkMutableDescriptorTypeListEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkMutableDescriptorTypeListVALVE* forUnmarshaling, uint8_t** ptr) {
+    VkMutableDescriptorTypeListEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((uint32_t*)&forUnmarshaling->descriptorTypeCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
     vkStream->alloc((void**)&forUnmarshaling->pDescriptorTypes,
@@ -23685,9 +26391,9 @@ void reservedunmarshal_VkMutableDescriptorTypeListVALVE(
     *ptr += forUnmarshaling->descriptorTypeCount * sizeof(const VkDescriptorType);
 }
 
-void reservedunmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
+void reservedunmarshal_VkMutableDescriptorTypeCreateInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkMutableDescriptorTypeCreateInfoVALVE* forUnmarshaling, uint8_t** ptr) {
+    VkMutableDescriptorTypeCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -23714,11 +26420,11 @@ void reservedunmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
     *ptr += sizeof(uint32_t);
     vkStream->alloc((void**)&forUnmarshaling->pMutableDescriptorTypeLists,
                     forUnmarshaling->mutableDescriptorTypeListCount *
-                        sizeof(const VkMutableDescriptorTypeListVALVE));
+                        sizeof(const VkMutableDescriptorTypeListEXT));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->mutableDescriptorTypeListCount; ++i) {
-        reservedunmarshal_VkMutableDescriptorTypeListVALVE(
+        reservedunmarshal_VkMutableDescriptorTypeListEXT(
             vkStream, rootType,
-            (VkMutableDescriptorTypeListVALVE*)(forUnmarshaling->pMutableDescriptorTypeLists + i),
+            (VkMutableDescriptorTypeListEXT*)(forUnmarshaling->pMutableDescriptorTypeLists + i),
             ptr);
     }
 }
@@ -23866,6 +26572,134 @@ void reservedunmarshal_VkPhysicalDeviceDrmPropertiesEXT(
 }
 
 #endif
+#ifdef VK_EXT_device_address_binding_report
+void reservedunmarshal_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->reportAddressBinding, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkDeviceAddressBindingCallbackDataEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceAddressBindingCallbackDataEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkDeviceAddressBindingFlagsEXT*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkDeviceAddressBindingFlagsEXT));
+    *ptr += sizeof(VkDeviceAddressBindingFlagsEXT);
+    memcpy((VkDeviceAddress*)&forUnmarshaling->baseAddress, *ptr, sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+    memcpy((VkDeviceSize*)&forUnmarshaling->size, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceAddressBindingTypeEXT*)&forUnmarshaling->bindingType, *ptr,
+           sizeof(VkDeviceAddressBindingTypeEXT));
+    *ptr += sizeof(VkDeviceAddressBindingTypeEXT);
+}
+
+#endif
+#ifdef VK_EXT_depth_clip_control
+void reservedunmarshal_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDepthClipControlFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->depthClipControl, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineViewportDepthClipControlCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->negativeOneToOne, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 void reservedunmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -24395,9 +27229,12 @@ void reservedunmarshal_VkImageFormatConstraintsInfoFUCHSIA(
     memcpy((uint32_t*)&forUnmarshaling->colorSpaceCount, *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
     vkStream->alloc((void**)&forUnmarshaling->pColorSpaces,
-                    sizeof(const VkSysmemColorSpaceFUCHSIA));
-    reservedunmarshal_VkSysmemColorSpaceFUCHSIA(
-        vkStream, rootType, (VkSysmemColorSpaceFUCHSIA*)(forUnmarshaling->pColorSpaces), ptr);
+                    forUnmarshaling->colorSpaceCount * sizeof(const VkSysmemColorSpaceFUCHSIA));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->colorSpaceCount; ++i) {
+        reservedunmarshal_VkSysmemColorSpaceFUCHSIA(
+            vkStream, rootType, (VkSysmemColorSpaceFUCHSIA*)(forUnmarshaling->pColorSpaces + i),
+            ptr);
+    }
 }
 
 void reservedunmarshal_VkImageConstraintsInfoFUCHSIA(VulkanStream* vkStream,
@@ -24638,6 +27475,159 @@ void reservedunmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
 }
 
 #endif
+#ifdef VK_EXT_pipeline_properties
+void reservedunmarshal_VkPipelinePropertiesIdentifierEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelinePropertiesIdentifierEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint8_t*)forUnmarshaling->pipelineIdentifier, *ptr, VK_UUID_SIZE * sizeof(uint8_t));
+    *ptr += VK_UUID_SIZE * sizeof(uint8_t);
+}
+
+void reservedunmarshal_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->pipelinePropertiesIdentifier, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+void reservedunmarshal_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->multisampledRenderToSingleSampled, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkSubpassResolvePerformanceQueryEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSubpassResolvePerformanceQueryEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->optimal, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkMultisampledRenderToSingleSampledInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkMultisampledRenderToSingleSampledInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->multisampledRenderToSingleSampledEnable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkSampleCountFlagBits*)&forUnmarshaling->rasterizationSamples, *ptr,
+           sizeof(VkSampleCountFlagBits));
+    *ptr += sizeof(VkSampleCountFlagBits);
+}
+
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void reservedunmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -24790,6 +27780,43 @@ void reservedunmarshal_VkPipelineColorWriteCreateInfoEXT(
 }
 
 #endif
+#ifdef VK_EXT_primitives_generated_query
+void reservedunmarshal_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->primitivesGeneratedQuery, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->primitivesGeneratedQueryWithRasterizerDiscard, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->primitivesGeneratedQueryWithNonZeroStreams, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
 #ifdef VK_GOOGLE_gfxstream
 void reservedunmarshal_VkImportColorBufferGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                                  VkImportColorBufferGOOGLE* forUnmarshaling,
@@ -24885,9 +27912,11 @@ void reservedunmarshal_VkCreateBlobGOOGLE(VulkanStream* vkStream, VkStructureTyp
 
 #endif
 #ifdef VK_EXT_global_priority_query
-void reservedunmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+#endif
+#ifdef VK_EXT_image_view_min_lod
+void reservedunmarshal_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -24910,13 +27939,13 @@ void reservedunmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((VkBool32*)&forUnmarshaling->globalPriorityQuery, *ptr, sizeof(VkBool32));
+    memcpy((VkBool32*)&forUnmarshaling->minLod, *ptr, sizeof(VkBool32));
     *ptr += sizeof(VkBool32);
 }
 
-void reservedunmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
+void reservedunmarshal_VkImageViewMinLodCreateInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkQueueFamilyGlobalPriorityPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
+    VkImageViewMinLodCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
     memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
     *ptr += sizeof(VkStructureType);
     if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
@@ -24939,11 +27968,8 @@ void reservedunmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
         reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
                                            ptr);
     }
-    memcpy((uint32_t*)&forUnmarshaling->priorityCount, *ptr, sizeof(uint32_t));
-    *ptr += sizeof(uint32_t);
-    memcpy((VkQueueGlobalPriorityEXT*)forUnmarshaling->priorities, *ptr,
-           VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT));
-    *ptr += VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT);
+    memcpy((float*)&forUnmarshaling->minLod, *ptr, sizeof(float));
+    *ptr += sizeof(float);
 }
 
 #endif
@@ -25026,8 +28052,731 @@ void reservedunmarshal_VkMultiDrawIndexedInfoEXT(VulkanStream* vkStream, VkStruc
 }
 
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+void reservedunmarshal_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->image2DViewOf3D, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->sampler2DViewOf3D, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_EXT_shader_tile_image
+void reservedunmarshal_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderTileImageFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->shaderTileImageColorReadAccess, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->shaderTileImageDepthReadAccess, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->shaderTileImageStencilReadAccess, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderTileImagePropertiesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->shaderTileImageCoherentReadAccelerated, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->shaderTileImageReadSampleFromPixelRateInvocation, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->shaderTileImageReadFromHelperInvocation, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_EXT_opacity_micromap
+void reservedunmarshal_VkMicromapUsageEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkMicromapUsageEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((uint32_t*)&forUnmarshaling->count, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->subdivisionLevel, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->format, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkDeviceOrHostAddressKHR* forUnmarshaling,
+                                                uint8_t** ptr) {
+    memcpy((VkDeviceAddress*)&forUnmarshaling->deviceAddress, *ptr, sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+}
+
+void reservedunmarshal_VkMicromapBuildInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkMicromapBuildInfoEXT* forUnmarshaling,
+                                              uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkMicromapTypeEXT*)&forUnmarshaling->type, *ptr, sizeof(VkMicromapTypeEXT));
+    *ptr += sizeof(VkMicromapTypeEXT);
+    memcpy((VkBuildMicromapFlagsEXT*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkBuildMicromapFlagsEXT));
+    *ptr += sizeof(VkBuildMicromapFlagsEXT);
+    memcpy((VkBuildMicromapModeEXT*)&forUnmarshaling->mode, *ptr, sizeof(VkBuildMicromapModeEXT));
+    *ptr += sizeof(VkBuildMicromapModeEXT);
+    memcpy((VkMicromapEXT*)&forUnmarshaling->dstMicromap, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->dstMicromap);
+    *ptr += 8;
+    memcpy((uint32_t*)&forUnmarshaling->usageCountsCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    // WARNING PTR CHECK
+    memcpy((VkMicromapUsageEXT**)&forUnmarshaling->pUsageCounts, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pUsageCounts);
+    *ptr += 8;
+    if (forUnmarshaling->pUsageCounts) {
+        vkStream->alloc((void**)&forUnmarshaling->pUsageCounts,
+                        forUnmarshaling->usageCountsCount * sizeof(const VkMicromapUsageEXT));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->usageCountsCount; ++i) {
+            reservedunmarshal_VkMicromapUsageEXT(
+                vkStream, rootType, (VkMicromapUsageEXT*)(forUnmarshaling->pUsageCounts + i), ptr);
+        }
+    }
+    reservedunmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->data), ptr);
+    reservedunmarshal_VkDeviceOrHostAddressKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->scratchData), ptr);
+    reservedunmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->triangleArray), ptr);
+    memcpy((VkDeviceSize*)&forUnmarshaling->triangleArrayStride, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+}
+
+void reservedunmarshal_VkMicromapCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkMicromapCreateInfoEXT* forUnmarshaling,
+                                               uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkMicromapCreateFlagsEXT*)&forUnmarshaling->createFlags, *ptr,
+           sizeof(VkMicromapCreateFlagsEXT));
+    *ptr += sizeof(VkMicromapCreateFlagsEXT);
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkBuffer*)&forUnmarshaling->buffer = (VkBuffer)unbox_VkBuffer((VkBuffer)(*&cgen_var_0));
+    memcpy((VkDeviceSize*)&forUnmarshaling->offset, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceSize*)&forUnmarshaling->size, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkMicromapTypeEXT*)&forUnmarshaling->type, *ptr, sizeof(VkMicromapTypeEXT));
+    *ptr += sizeof(VkMicromapTypeEXT);
+    memcpy((VkDeviceAddress*)&forUnmarshaling->deviceAddress, *ptr, sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+}
+
+void reservedunmarshal_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->micromap, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->micromapCaptureReplay, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->micromapHostCommands, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->maxOpacity2StateSubdivisionLevel, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxOpacity4StateSubdivisionLevel, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkMicromapVersionInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkMicromapVersionInfoEXT* forUnmarshaling,
+                                                uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pVersionData,
+                    2 * VK_UUID_SIZE * sizeof(const uint8_t));
+    memcpy((uint8_t*)forUnmarshaling->pVersionData, *ptr, 2 * VK_UUID_SIZE * sizeof(const uint8_t));
+    *ptr += 2 * VK_UUID_SIZE * sizeof(const uint8_t);
+}
+
+void reservedunmarshal_VkCopyMicromapToMemoryInfoEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkCopyMicromapToMemoryInfoEXT* forUnmarshaling,
+                                                     uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkMicromapEXT*)&forUnmarshaling->src, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->src);
+    *ptr += 8;
+    reservedunmarshal_VkDeviceOrHostAddressKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressKHR*)(&forUnmarshaling->dst), ptr);
+    memcpy((VkCopyMicromapModeEXT*)&forUnmarshaling->mode, *ptr, sizeof(VkCopyMicromapModeEXT));
+    *ptr += sizeof(VkCopyMicromapModeEXT);
+}
+
+void reservedunmarshal_VkCopyMemoryToMicromapInfoEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkCopyMemoryToMicromapInfoEXT* forUnmarshaling,
+                                                     uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    reservedunmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->src), ptr);
+    memcpy((VkMicromapEXT*)&forUnmarshaling->dst, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->dst);
+    *ptr += 8;
+    memcpy((VkCopyMicromapModeEXT*)&forUnmarshaling->mode, *ptr, sizeof(VkCopyMicromapModeEXT));
+    *ptr += sizeof(VkCopyMicromapModeEXT);
+}
+
+void reservedunmarshal_VkCopyMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkCopyMicromapInfoEXT* forUnmarshaling,
+                                             uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkMicromapEXT*)&forUnmarshaling->src, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->src);
+    *ptr += 8;
+    memcpy((VkMicromapEXT*)&forUnmarshaling->dst, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->dst);
+    *ptr += 8;
+    memcpy((VkCopyMicromapModeEXT*)&forUnmarshaling->mode, *ptr, sizeof(VkCopyMicromapModeEXT));
+    *ptr += sizeof(VkCopyMicromapModeEXT);
+}
+
+void reservedunmarshal_VkMicromapBuildSizesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkMicromapBuildSizesInfoEXT* forUnmarshaling,
+                                                   uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkDeviceSize*)&forUnmarshaling->micromapSize, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceSize*)&forUnmarshaling->buildScratchSize, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkBool32*)&forUnmarshaling->discardable, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkAccelerationStructureTrianglesOpacityMicromapEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkIndexType*)&forUnmarshaling->indexType, *ptr, sizeof(VkIndexType));
+    *ptr += sizeof(VkIndexType);
+    reservedunmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->indexBuffer), ptr);
+    memcpy((VkDeviceSize*)&forUnmarshaling->indexStride, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((uint32_t*)&forUnmarshaling->baseTriangle, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->usageCountsCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    // WARNING PTR CHECK
+    memcpy((VkMicromapUsageEXT**)&forUnmarshaling->pUsageCounts, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pUsageCounts);
+    *ptr += 8;
+    if (forUnmarshaling->pUsageCounts) {
+        vkStream->alloc((void**)&forUnmarshaling->pUsageCounts,
+                        forUnmarshaling->usageCountsCount * sizeof(const VkMicromapUsageEXT));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->usageCountsCount; ++i) {
+            reservedunmarshal_VkMicromapUsageEXT(
+                vkStream, rootType, (VkMicromapUsageEXT*)(forUnmarshaling->pUsageCounts + i), ptr);
+        }
+    }
+    memcpy((VkMicromapEXT*)&forUnmarshaling->micromap, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->micromap);
+    *ptr += 8;
+}
+
+void reservedunmarshal_VkMicromapTriangleEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkMicromapTriangleEXT* forUnmarshaling,
+                                             uint8_t** ptr) {
+    memcpy((uint32_t*)&forUnmarshaling->dataOffset, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint16_t*)&forUnmarshaling->subdivisionLevel, *ptr, sizeof(uint16_t));
+    *ptr += sizeof(uint16_t);
+    memcpy((uint16_t*)&forUnmarshaling->format, *ptr, sizeof(uint16_t));
+    *ptr += sizeof(uint16_t);
+}
+
+#endif
+#ifdef VK_NV_displacement_micromap
+void reservedunmarshal_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->displacementMicromap, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->maxDisplacementMicromapSubdivisionLevel, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkAccelerationStructureTrianglesDisplacementMicromapNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkFormat*)&forUnmarshaling->displacementBiasAndScaleFormat, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+    memcpy((VkFormat*)&forUnmarshaling->displacementVectorFormat, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+    reservedunmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType,
+        (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->displacementBiasAndScaleBuffer), ptr);
+    memcpy((VkDeviceSize*)&forUnmarshaling->displacementBiasAndScaleStride, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    reservedunmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType,
+        (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->displacementVectorBuffer), ptr);
+    memcpy((VkDeviceSize*)&forUnmarshaling->displacementVectorStride, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    reservedunmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType,
+        (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->displacedMicromapPrimitiveFlags), ptr);
+    memcpy((VkDeviceSize*)&forUnmarshaling->displacedMicromapPrimitiveFlagsStride, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkIndexType*)&forUnmarshaling->indexType, *ptr, sizeof(VkIndexType));
+    *ptr += sizeof(VkIndexType);
+    reservedunmarshal_VkDeviceOrHostAddressConstKHR(
+        vkStream, rootType, (VkDeviceOrHostAddressConstKHR*)(&forUnmarshaling->indexBuffer), ptr);
+    memcpy((VkDeviceSize*)&forUnmarshaling->indexStride, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((uint32_t*)&forUnmarshaling->baseTriangle, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->usageCountsCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    // WARNING PTR CHECK
+    memcpy((VkMicromapUsageEXT**)&forUnmarshaling->pUsageCounts, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pUsageCounts);
+    *ptr += 8;
+    if (forUnmarshaling->pUsageCounts) {
+        vkStream->alloc((void**)&forUnmarshaling->pUsageCounts,
+                        forUnmarshaling->usageCountsCount * sizeof(const VkMicromapUsageEXT));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->usageCountsCount; ++i) {
+            reservedunmarshal_VkMicromapUsageEXT(
+                vkStream, rootType, (VkMicromapUsageEXT*)(forUnmarshaling->pUsageCounts + i), ptr);
+        }
+    }
+    memcpy((VkMicromapEXT*)&forUnmarshaling->micromap, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->micromap);
+    *ptr += 8;
+}
+
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void reservedunmarshal_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->clustercullingShader, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->multiviewClusterCullingShader, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)forUnmarshaling->maxWorkGroupCount, *ptr, 3 * sizeof(uint32_t));
+    *ptr += 3 * sizeof(uint32_t);
+    memcpy((uint32_t*)forUnmarshaling->maxWorkGroupSize, *ptr, 3 * sizeof(uint32_t));
+    *ptr += 3 * sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxOutputClusterCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((VkDeviceSize*)&forUnmarshaling->indirectBufferOffsetAlignment, *ptr,
+           sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+}
+
+#endif
 #ifdef VK_EXT_border_color_swizzle
 void reservedunmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -25123,14 +28872,2120 @@ void reservedunmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
 }
 
 #endif
-#ifdef VK_KHR_acceleration_structure
-void reservedunmarshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkDeviceOrHostAddressKHR* forUnmarshaling,
-                                                uint8_t** ptr) {
-    memcpy((VkDeviceAddress*)&forUnmarshaling->deviceAddress, *ptr, sizeof(VkDeviceAddress));
+#ifdef VK_ARM_shader_core_properties
+void reservedunmarshal_VkPhysicalDeviceShaderCorePropertiesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderCorePropertiesARM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->pixelRate, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->texelRate, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->fmaRate, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+void reservedunmarshal_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->imageSlicedViewOf3D, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkImageViewSlicedCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageViewSlicedCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->sliceOffset, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->sliceCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void reservedunmarshal_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->descriptorSetHostMapping, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkDescriptorSetBindingReferenceVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorSetBindingReferenceVALVE* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    uint64_t cgen_var_0;
+    memcpy((uint64_t*)&cgen_var_0, *ptr, 1 * 8);
+    *ptr += 1 * 8;
+    *(VkDescriptorSetLayout*)&forUnmarshaling->descriptorSetLayout =
+        (VkDescriptorSetLayout)unbox_VkDescriptorSetLayout((VkDescriptorSetLayout)(*&cgen_var_0));
+    memcpy((uint32_t*)&forUnmarshaling->binding, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorSetLayoutHostMappingInfoVALVE* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((size_t*)&forUnmarshaling->descriptorOffset, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->descriptorOffset);
+    *ptr += 8;
+    memcpy((uint32_t*)&forUnmarshaling->descriptorSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+void reservedunmarshal_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->depthClampZeroOne, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+void reservedunmarshal_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->nonSeamlessCubeMap, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+void reservedunmarshal_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->fragmentDensityMapOffset, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    reservedunmarshal_VkExtent2D(
+        vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->fragmentDensityOffsetGranularity), ptr);
+}
+
+void reservedunmarshal_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->fragmentDensityOffsetCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pFragmentDensityOffsets,
+                    forUnmarshaling->fragmentDensityOffsetCount * sizeof(const VkOffset2D));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->fragmentDensityOffsetCount; ++i) {
+        reservedunmarshal_VkOffset2D(
+            vkStream, rootType, (VkOffset2D*)(forUnmarshaling->pFragmentDensityOffsets + i), ptr);
+    }
+}
+
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void reservedunmarshal_VkCopyMemoryIndirectCommandNV(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkCopyMemoryIndirectCommandNV* forUnmarshaling,
+                                                     uint8_t** ptr) {
+    memcpy((VkDeviceAddress*)&forUnmarshaling->srcAddress, *ptr, sizeof(VkDeviceAddress));
     *ptr += sizeof(VkDeviceAddress);
+    memcpy((VkDeviceAddress*)&forUnmarshaling->dstAddress, *ptr, sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+    memcpy((VkDeviceSize*)&forUnmarshaling->size, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+}
+
+void reservedunmarshal_VkCopyMemoryToImageIndirectCommandNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkCopyMemoryToImageIndirectCommandNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkDeviceAddress*)&forUnmarshaling->srcAddress, *ptr, sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+    memcpy((uint32_t*)&forUnmarshaling->bufferRowLength, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->bufferImageHeight, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    reservedunmarshal_VkImageSubresourceLayers(
+        vkStream, rootType, (VkImageSubresourceLayers*)(&forUnmarshaling->imageSubresource), ptr);
+    reservedunmarshal_VkOffset3D(vkStream, rootType, (VkOffset3D*)(&forUnmarshaling->imageOffset),
+                                 ptr);
+    reservedunmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->imageExtent),
+                                 ptr);
 }
 
+void reservedunmarshal_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->indirectCopy, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkQueueFlags*)&forUnmarshaling->supportedQueues, *ptr, sizeof(VkQueueFlags));
+    *ptr += sizeof(VkQueueFlags);
+}
+
+#endif
+#ifdef VK_NV_memory_decompression
+void reservedunmarshal_VkDecompressMemoryRegionNV(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkDecompressMemoryRegionNV* forUnmarshaling,
+                                                  uint8_t** ptr) {
+    memcpy((VkDeviceAddress*)&forUnmarshaling->srcAddress, *ptr, sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+    memcpy((VkDeviceAddress*)&forUnmarshaling->dstAddress, *ptr, sizeof(VkDeviceAddress));
+    *ptr += sizeof(VkDeviceAddress);
+    memcpy((VkDeviceSize*)&forUnmarshaling->compressedSize, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkDeviceSize*)&forUnmarshaling->decompressedSize, *ptr, sizeof(VkDeviceSize));
+    *ptr += sizeof(VkDeviceSize);
+    memcpy((VkMemoryDecompressionMethodFlagsNV*)&forUnmarshaling->decompressionMethod, *ptr,
+           sizeof(VkMemoryDecompressionMethodFlagsNV));
+    *ptr += sizeof(VkMemoryDecompressionMethodFlagsNV);
+}
+
+void reservedunmarshal_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->memoryDecompression, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkMemoryDecompressionMethodFlagsNV*)&forUnmarshaling->decompressionMethods, *ptr,
+           sizeof(VkMemoryDecompressionMethodFlagsNV));
+    *ptr += sizeof(VkMemoryDecompressionMethodFlagsNV);
+    memcpy((uint64_t*)&forUnmarshaling->maxDecompressionIndirectCount, *ptr, sizeof(uint64_t));
+    *ptr += sizeof(uint64_t);
+}
+
+#endif
+#ifdef VK_NV_linear_color_attachment
+void reservedunmarshal_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->linearColorAttachment, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+void reservedunmarshal_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->imageCompressionControlSwapchain, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_QCOM_image_processing
+void reservedunmarshal_VkImageViewSampleWeightCreateInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageViewSampleWeightCreateInfoQCOM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    reservedunmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->filterCenter),
+                                 ptr);
+    reservedunmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->filterSize),
+                                 ptr);
+    memcpy((uint32_t*)&forUnmarshaling->numPhases, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageProcessingFeaturesQCOM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->textureSampleWeighted, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->textureBoxFilter, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->textureBlockMatch, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageProcessingPropertiesQCOM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->maxWeightFilterPhases, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    reservedunmarshal_VkExtent2D(vkStream, rootType,
+                                 (VkExtent2D*)(&forUnmarshaling->maxWeightFilterDimension), ptr);
+    reservedunmarshal_VkExtent2D(vkStream, rootType,
+                                 (VkExtent2D*)(&forUnmarshaling->maxBlockMatchRegion), ptr);
+    reservedunmarshal_VkExtent2D(vkStream, rootType,
+                                 (VkExtent2D*)(&forUnmarshaling->maxBoxFilterBlockSize), ptr);
+}
+
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void reservedunmarshal_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3TessellationDomainOrigin, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3DepthClampEnable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3PolygonMode, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3RasterizationSamples, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3SampleMask, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3AlphaToCoverageEnable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3AlphaToOneEnable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3LogicOpEnable, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3ColorBlendEnable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3ColorBlendEquation, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3ColorWriteMask, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3RasterizationStream, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3ConservativeRasterizationMode, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3ExtraPrimitiveOverestimationSize, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3DepthClipEnable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3SampleLocationsEnable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3ColorBlendAdvanced, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3ProvokingVertexMode, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3LineRasterizationMode, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3LineStippleEnable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3DepthClipNegativeOneToOne, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3ViewportWScalingEnable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3ViewportSwizzle, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageToColorEnable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageToColorLocation, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageModulationMode, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageModulationTableEnable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageModulationTable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3CoverageReductionMode, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3RepresentativeFragmentTestEnable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->extendedDynamicState3ShadingRateImageEnable, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->dynamicPrimitiveTopologyUnrestricted, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkColorBlendEquationEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkColorBlendEquationEXT* forUnmarshaling,
+                                               uint8_t** ptr) {
+    memcpy((VkBlendFactor*)&forUnmarshaling->srcColorBlendFactor, *ptr, sizeof(VkBlendFactor));
+    *ptr += sizeof(VkBlendFactor);
+    memcpy((VkBlendFactor*)&forUnmarshaling->dstColorBlendFactor, *ptr, sizeof(VkBlendFactor));
+    *ptr += sizeof(VkBlendFactor);
+    memcpy((VkBlendOp*)&forUnmarshaling->colorBlendOp, *ptr, sizeof(VkBlendOp));
+    *ptr += sizeof(VkBlendOp);
+    memcpy((VkBlendFactor*)&forUnmarshaling->srcAlphaBlendFactor, *ptr, sizeof(VkBlendFactor));
+    *ptr += sizeof(VkBlendFactor);
+    memcpy((VkBlendFactor*)&forUnmarshaling->dstAlphaBlendFactor, *ptr, sizeof(VkBlendFactor));
+    *ptr += sizeof(VkBlendFactor);
+    memcpy((VkBlendOp*)&forUnmarshaling->alphaBlendOp, *ptr, sizeof(VkBlendOp));
+    *ptr += sizeof(VkBlendOp);
+}
+
+void reservedunmarshal_VkColorBlendAdvancedEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkColorBlendAdvancedEXT* forUnmarshaling,
+                                               uint8_t** ptr) {
+    memcpy((VkBlendOp*)&forUnmarshaling->advancedBlendOp, *ptr, sizeof(VkBlendOp));
+    *ptr += sizeof(VkBlendOp);
+    memcpy((VkBool32*)&forUnmarshaling->srcPremultiplied, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->dstPremultiplied, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBlendOverlapEXT*)&forUnmarshaling->blendOverlap, *ptr, sizeof(VkBlendOverlapEXT));
+    *ptr += sizeof(VkBlendOverlapEXT);
+    memcpy((VkBool32*)&forUnmarshaling->clampResults, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+void reservedunmarshal_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->subpassMergeFeedback, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkRenderPassCreationControlEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassCreationControlEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->disallowMerging, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkRenderPassCreationFeedbackInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassCreationFeedbackInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((uint32_t*)&forUnmarshaling->postMergeSubpassCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkRenderPassCreationFeedbackCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassCreationFeedbackCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pRenderPassFeedback,
+                    sizeof(VkRenderPassCreationFeedbackInfoEXT));
+    reservedunmarshal_VkRenderPassCreationFeedbackInfoEXT(
+        vkStream, rootType,
+        (VkRenderPassCreationFeedbackInfoEXT*)(forUnmarshaling->pRenderPassFeedback), ptr);
+}
+
+void reservedunmarshal_VkRenderPassSubpassFeedbackInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassSubpassFeedbackInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkSubpassMergeStatusEXT*)&forUnmarshaling->subpassMergeStatus, *ptr,
+           sizeof(VkSubpassMergeStatusEXT));
+    *ptr += sizeof(VkSubpassMergeStatusEXT);
+    memcpy((char*)forUnmarshaling->description, *ptr, VK_MAX_DESCRIPTION_SIZE * sizeof(char));
+    *ptr += VK_MAX_DESCRIPTION_SIZE * sizeof(char);
+    memcpy((uint32_t*)&forUnmarshaling->postMergeIndex, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassSubpassFeedbackCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    vkStream->alloc((void**)&forUnmarshaling->pSubpassFeedback,
+                    sizeof(VkRenderPassSubpassFeedbackInfoEXT));
+    reservedunmarshal_VkRenderPassSubpassFeedbackInfoEXT(
+        vkStream, rootType,
+        (VkRenderPassSubpassFeedbackInfoEXT*)(forUnmarshaling->pSubpassFeedback), ptr);
+}
+
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+void reservedunmarshal_VkDirectDriverLoadingInfoLUNARG(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDirectDriverLoadingInfoLUNARG* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkDirectDriverLoadingFlagsLUNARG*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkDirectDriverLoadingFlagsLUNARG));
+    *ptr += sizeof(VkDirectDriverLoadingFlagsLUNARG);
+    memcpy((PFN_vkGetInstanceProcAddrLUNARG*)&forUnmarshaling->pfnGetInstanceProcAddr, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pfnGetInstanceProcAddr);
+    *ptr += 8;
+}
+
+void reservedunmarshal_VkDirectDriverLoadingListLUNARG(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDirectDriverLoadingListLUNARG* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkDirectDriverLoadingModeLUNARG*)&forUnmarshaling->mode, *ptr,
+           sizeof(VkDirectDriverLoadingModeLUNARG));
+    *ptr += sizeof(VkDirectDriverLoadingModeLUNARG);
+    memcpy((uint32_t*)&forUnmarshaling->driverCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pDrivers,
+                    forUnmarshaling->driverCount * sizeof(const VkDirectDriverLoadingInfoLUNARG));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->driverCount; ++i) {
+        reservedunmarshal_VkDirectDriverLoadingInfoLUNARG(
+            vkStream, rootType, (VkDirectDriverLoadingInfoLUNARG*)(forUnmarshaling->pDrivers + i),
+            ptr);
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void reservedunmarshal_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->shaderModuleIdentifier, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint8_t*)forUnmarshaling->shaderModuleIdentifierAlgorithmUUID, *ptr,
+           VK_UUID_SIZE * sizeof(uint8_t));
+    *ptr += VK_UUID_SIZE * sizeof(uint8_t);
+}
+
+void reservedunmarshal_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->identifierSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pIdentifier,
+                    forUnmarshaling->identifierSize * sizeof(const uint8_t));
+    memcpy((uint8_t*)forUnmarshaling->pIdentifier, *ptr,
+           forUnmarshaling->identifierSize * sizeof(const uint8_t));
+    *ptr += forUnmarshaling->identifierSize * sizeof(const uint8_t);
+}
+
+void reservedunmarshal_VkShaderModuleIdentifierEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkShaderModuleIdentifierEXT* forUnmarshaling,
+                                                   uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->identifierSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint8_t*)forUnmarshaling->identifier, *ptr,
+           VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t));
+    *ptr += VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t);
+}
+
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+void reservedunmarshal_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpticalFlowFeaturesNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->opticalFlow, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpticalFlowPropertiesNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkOpticalFlowGridSizeFlagsNV*)&forUnmarshaling->supportedOutputGridSizes, *ptr,
+           sizeof(VkOpticalFlowGridSizeFlagsNV));
+    *ptr += sizeof(VkOpticalFlowGridSizeFlagsNV);
+    memcpy((VkOpticalFlowGridSizeFlagsNV*)&forUnmarshaling->supportedHintGridSizes, *ptr,
+           sizeof(VkOpticalFlowGridSizeFlagsNV));
+    *ptr += sizeof(VkOpticalFlowGridSizeFlagsNV);
+    memcpy((VkBool32*)&forUnmarshaling->hintSupported, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->costSupported, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->bidirectionalFlowSupported, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->globalFlowSupported, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((uint32_t*)&forUnmarshaling->minWidth, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->minHeight, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxWidth, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxHeight, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxNumRegionsOfInterest, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkOpticalFlowImageFormatInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpticalFlowImageFormatInfoNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkOpticalFlowUsageFlagsNV*)&forUnmarshaling->usage, *ptr,
+           sizeof(VkOpticalFlowUsageFlagsNV));
+    *ptr += sizeof(VkOpticalFlowUsageFlagsNV);
+}
+
+void reservedunmarshal_VkOpticalFlowImageFormatPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpticalFlowImageFormatPropertiesNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkFormat*)&forUnmarshaling->format, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+}
+
+void reservedunmarshal_VkOpticalFlowSessionCreateInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpticalFlowSessionCreateInfoNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->width, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->height, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((VkFormat*)&forUnmarshaling->imageFormat, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+    memcpy((VkFormat*)&forUnmarshaling->flowVectorFormat, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+    memcpy((VkFormat*)&forUnmarshaling->costFormat, *ptr, sizeof(VkFormat));
+    *ptr += sizeof(VkFormat);
+    memcpy((VkOpticalFlowGridSizeFlagsNV*)&forUnmarshaling->outputGridSize, *ptr,
+           sizeof(VkOpticalFlowGridSizeFlagsNV));
+    *ptr += sizeof(VkOpticalFlowGridSizeFlagsNV);
+    memcpy((VkOpticalFlowGridSizeFlagsNV*)&forUnmarshaling->hintGridSize, *ptr,
+           sizeof(VkOpticalFlowGridSizeFlagsNV));
+    *ptr += sizeof(VkOpticalFlowGridSizeFlagsNV);
+    memcpy((VkOpticalFlowPerformanceLevelNV*)&forUnmarshaling->performanceLevel, *ptr,
+           sizeof(VkOpticalFlowPerformanceLevelNV));
+    *ptr += sizeof(VkOpticalFlowPerformanceLevelNV);
+    memcpy((VkOpticalFlowSessionCreateFlagsNV*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkOpticalFlowSessionCreateFlagsNV));
+    *ptr += sizeof(VkOpticalFlowSessionCreateFlagsNV);
+}
+
+void reservedunmarshal_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpticalFlowSessionCreatePrivateDataInfoNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->id, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->size, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pPrivateData, sizeof(const uint8_t));
+    memcpy((void*)forUnmarshaling->pPrivateData, *ptr, sizeof(const uint8_t));
+    *ptr += sizeof(const uint8_t);
+}
+
+void reservedunmarshal_VkOpticalFlowExecuteInfoNV(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkOpticalFlowExecuteInfoNV* forUnmarshaling,
+                                                  uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkOpticalFlowExecuteFlagsNV*)&forUnmarshaling->flags, *ptr,
+           sizeof(VkOpticalFlowExecuteFlagsNV));
+    *ptr += sizeof(VkOpticalFlowExecuteFlagsNV);
+    memcpy((uint32_t*)&forUnmarshaling->regionCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pRegions,
+                    forUnmarshaling->regionCount * sizeof(const VkRect2D));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->regionCount; ++i) {
+        reservedunmarshal_VkRect2D(vkStream, rootType, (VkRect2D*)(forUnmarshaling->pRegions + i),
+                                   ptr);
+    }
+}
+
+#endif
+#ifdef VK_EXT_legacy_dithering
+void reservedunmarshal_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->legacyDithering, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+void reservedunmarshal_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->pipelineProtectedAccess, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_EXT_shader_object
+void reservedunmarshal_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderObjectFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->shaderObject, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderObjectPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint8_t*)forUnmarshaling->shaderBinaryUUID, *ptr, VK_UUID_SIZE * sizeof(uint8_t));
+    *ptr += VK_UUID_SIZE * sizeof(uint8_t);
+    memcpy((uint32_t*)&forUnmarshaling->shaderBinaryVersion, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+void reservedunmarshal_VkShaderCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkShaderCreateInfoEXT* forUnmarshaling,
+                                             uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkShaderCreateFlagsEXT*)&forUnmarshaling->flags, *ptr, sizeof(VkShaderCreateFlagsEXT));
+    *ptr += sizeof(VkShaderCreateFlagsEXT);
+    memcpy((VkShaderStageFlagBits*)&forUnmarshaling->stage, *ptr, sizeof(VkShaderStageFlagBits));
+    *ptr += sizeof(VkShaderStageFlagBits);
+    memcpy((VkShaderStageFlags*)&forUnmarshaling->nextStage, *ptr, sizeof(VkShaderStageFlags));
+    *ptr += sizeof(VkShaderStageFlags);
+    memcpy((VkShaderCodeTypeEXT*)&forUnmarshaling->codeType, *ptr, sizeof(VkShaderCodeTypeEXT));
+    *ptr += sizeof(VkShaderCodeTypeEXT);
+    memcpy((size_t*)&forUnmarshaling->codeSize, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->codeSize);
+    *ptr += 8;
+    vkStream->alloc((void**)&forUnmarshaling->pCode,
+                    forUnmarshaling->codeSize * sizeof(const uint8_t));
+    memcpy((void*)forUnmarshaling->pCode, *ptr, forUnmarshaling->codeSize * sizeof(const uint8_t));
+    *ptr += forUnmarshaling->codeSize * sizeof(const uint8_t);
+    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
+        // WARNING PTR CHECK
+        memcpy((char**)&forUnmarshaling->pName, (*ptr), 8);
+        android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pName);
+        *ptr += 8;
+        if (forUnmarshaling->pName) {
+            vkStream->loadStringInPlaceWithStreamPtr((char**)&forUnmarshaling->pName, ptr);
+        }
+    } else {
+        vkStream->loadStringInPlaceWithStreamPtr((char**)&forUnmarshaling->pName, ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->setLayoutCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    // WARNING PTR CHECK
+    memcpy((VkDescriptorSetLayout**)&forUnmarshaling->pSetLayouts, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pSetLayouts);
+    *ptr += 8;
+    if (forUnmarshaling->pSetLayouts) {
+        vkStream->alloc((void**)&forUnmarshaling->pSetLayouts,
+                        forUnmarshaling->setLayoutCount * sizeof(const VkDescriptorSetLayout));
+        if (forUnmarshaling->setLayoutCount) {
+            uint8_t* cgen_var_1_0_ptr = (uint8_t*)(*ptr);
+            *ptr += 8 * forUnmarshaling->setLayoutCount;
+            if (forUnmarshaling) {
+                for (uint32_t k = 0; k < forUnmarshaling->setLayoutCount; ++k) {
+                    uint64_t tmpval;
+                    memcpy(&tmpval, cgen_var_1_0_ptr + k * 8, sizeof(uint64_t));
+                    *(((VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts) + k) =
+                        (VkDescriptorSetLayout)unbox_VkDescriptorSetLayout(
+                            (VkDescriptorSetLayout)tmpval);
+                }
+            }
+        }
+    }
+    memcpy((uint32_t*)&forUnmarshaling->pushConstantRangeCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    // WARNING PTR CHECK
+    memcpy((VkPushConstantRange**)&forUnmarshaling->pPushConstantRanges, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pPushConstantRanges);
+    *ptr += 8;
+    if (forUnmarshaling->pPushConstantRanges) {
+        vkStream->alloc(
+            (void**)&forUnmarshaling->pPushConstantRanges,
+            forUnmarshaling->pushConstantRangeCount * sizeof(const VkPushConstantRange));
+        for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pushConstantRangeCount; ++i) {
+            reservedunmarshal_VkPushConstantRange(
+                vkStream, rootType,
+                (VkPushConstantRange*)(forUnmarshaling->pPushConstantRanges + i), ptr);
+        }
+    }
+    // WARNING PTR CHECK
+    memcpy((VkSpecializationInfo**)&forUnmarshaling->pSpecializationInfo, (*ptr), 8);
+    android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pSpecializationInfo);
+    *ptr += 8;
+    if (forUnmarshaling->pSpecializationInfo) {
+        vkStream->alloc((void**)&forUnmarshaling->pSpecializationInfo,
+                        sizeof(const VkSpecializationInfo));
+        reservedunmarshal_VkSpecializationInfo(
+            vkStream, rootType, (VkSpecializationInfo*)(forUnmarshaling->pSpecializationInfo), ptr);
+    }
+}
+
+#endif
+#ifdef VK_QCOM_tile_properties
+void reservedunmarshal_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceTilePropertiesFeaturesQCOM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->tileProperties, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkTilePropertiesQCOM(VulkanStream* vkStream, VkStructureType rootType,
+                                            VkTilePropertiesQCOM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    reservedunmarshal_VkExtent3D(vkStream, rootType, (VkExtent3D*)(&forUnmarshaling->tileSize),
+                                 ptr);
+    reservedunmarshal_VkExtent2D(vkStream, rootType, (VkExtent2D*)(&forUnmarshaling->apronSize),
+                                 ptr);
+    reservedunmarshal_VkOffset2D(vkStream, rootType, (VkOffset2D*)(&forUnmarshaling->origin), ptr);
+}
+
+#endif
+#ifdef VK_SEC_amigo_profiling
+void reservedunmarshal_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAmigoProfilingFeaturesSEC* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->amigoProfiling, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkAmigoProfilingSubmitInfoSEC(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkAmigoProfilingSubmitInfoSEC* forUnmarshaling,
+                                                     uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint64_t*)&forUnmarshaling->firstDrawTimestamp, *ptr, sizeof(uint64_t));
+    *ptr += sizeof(uint64_t);
+    memcpy((uint64_t*)&forUnmarshaling->swapBufferTimestamp, *ptr, sizeof(uint64_t));
+    *ptr += sizeof(uint64_t);
+}
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+void reservedunmarshal_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->multiviewPerViewViewports, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+void reservedunmarshal_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkRayTracingInvocationReorderModeNV*)&forUnmarshaling
+               ->rayTracingInvocationReorderReorderingHint,
+           *ptr, sizeof(VkRayTracingInvocationReorderModeNV));
+    *ptr += sizeof(VkRayTracingInvocationReorderModeNV);
+}
+
+void reservedunmarshal_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->rayTracingInvocationReorder, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+void reservedunmarshal_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->shaderCoreBuiltins, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint64_t*)&forUnmarshaling->shaderCoreMask, *ptr, sizeof(uint64_t));
+    *ptr += sizeof(uint64_t);
+    memcpy((uint32_t*)&forUnmarshaling->shaderCoreCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->shaderWarpsPerCore, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+void reservedunmarshal_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->pipelineLibraryGroupHandles, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+void reservedunmarshal_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->multiviewPerViewRenderAreas, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->perViewRenderAreaCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    vkStream->alloc((void**)&forUnmarshaling->pPerViewRenderAreas,
+                    forUnmarshaling->perViewRenderAreaCount * sizeof(const VkRect2D));
+    for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->perViewRenderAreaCount; ++i) {
+        reservedunmarshal_VkRect2D(vkStream, rootType,
+                                   (VkRect2D*)(forUnmarshaling->pPerViewRenderAreas + i), ptr);
+    }
+}
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+void reservedunmarshal_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->attachmentFeedbackLoopDynamicState, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+#endif
+#ifdef VK_KHR_acceleration_structure
 void reservedunmarshal_VkAccelerationStructureBuildRangeInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
     VkAccelerationStructureBuildRangeInfoKHR* forUnmarshaling, uint8_t** ptr) {
@@ -26066,6 +31921,143 @@ void reservedunmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
 }
 
 #endif
+#ifdef VK_EXT_mesh_shader
+void reservedunmarshal_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMeshShaderFeaturesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((VkBool32*)&forUnmarshaling->taskShader, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->meshShader, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->multiviewMeshShader, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->primitiveFragmentShadingRateMeshShader, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->meshShaderQueries, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMeshShaderPropertiesEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+    *ptr += sizeof(VkStructureType);
+    if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+        rootType = forUnmarshaling->sType;
+    }
+    uint32_t pNext_size;
+    memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+    android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+    *ptr += sizeof(uint32_t);
+    forUnmarshaling->pNext = nullptr;
+    if (pNext_size) {
+        vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+        memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+        *ptr += sizeof(VkStructureType);
+        VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+        vkStream->alloc((void**)&forUnmarshaling->pNext,
+                        goldfish_vk_extension_struct_size_with_stream_features(
+                            vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+        *(VkStructureType*)forUnmarshaling->pNext = extType;
+        reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+                                           ptr);
+    }
+    memcpy((uint32_t*)&forUnmarshaling->maxTaskWorkGroupTotalCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)forUnmarshaling->maxTaskWorkGroupCount, *ptr, 3 * sizeof(uint32_t));
+    *ptr += 3 * sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxTaskWorkGroupInvocations, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)forUnmarshaling->maxTaskWorkGroupSize, *ptr, 3 * sizeof(uint32_t));
+    *ptr += 3 * sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxTaskPayloadSize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxTaskSharedMemorySize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxTaskPayloadAndSharedMemorySize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMeshWorkGroupTotalCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)forUnmarshaling->maxMeshWorkGroupCount, *ptr, 3 * sizeof(uint32_t));
+    *ptr += 3 * sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMeshWorkGroupInvocations, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)forUnmarshaling->maxMeshWorkGroupSize, *ptr, 3 * sizeof(uint32_t));
+    *ptr += 3 * sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMeshSharedMemorySize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMeshPayloadAndSharedMemorySize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMeshOutputMemorySize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMeshPayloadAndOutputMemorySize, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMeshOutputComponents, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMeshOutputVertices, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMeshOutputPrimitives, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMeshOutputLayers, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxMeshMultiviewViewCount, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->meshOutputPerVertexGranularity, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->meshOutputPerPrimitiveGranularity, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxPreferredTaskWorkGroupInvocations, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->maxPreferredMeshWorkGroupInvocations, *ptr,
+           sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((VkBool32*)&forUnmarshaling->prefersLocalInvocationVertexOutput, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->prefersLocalInvocationPrimitiveOutput, *ptr,
+           sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->prefersCompactVertexOutput, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+    memcpy((VkBool32*)&forUnmarshaling->prefersCompactPrimitiveOutput, *ptr, sizeof(VkBool32));
+    *ptr += sizeof(VkBool32);
+}
+
+void reservedunmarshal_VkDrawMeshTasksIndirectCommandEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDrawMeshTasksIndirectCommandEXT* forUnmarshaling, uint8_t** ptr) {
+    memcpy((uint32_t*)&forUnmarshaling->groupCountX, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->groupCountY, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+    memcpy((uint32_t*)&forUnmarshaling->groupCountZ, *ptr, sizeof(uint32_t));
+    *ptr += sizeof(uint32_t);
+}
+
+#endif
 void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType rootType,
                                         void* structExtension_out, uint8_t** ptr) {
     VkInstanceCreateInfo* structAccess = (VkInstanceCreateInfo*)(structExtension_out);
@@ -26087,6 +32079,14 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
     }
     uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
     switch (structType) {
+#ifdef VK_VERSION_1_0
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
+            reservedunmarshal_VkShaderModuleCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkShaderModuleCreateInfo*>(structExtension_out), ptr);
+            break;
+        }
+#endif
 #ifdef VK_VERSION_1_1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
             reservedunmarshal_VkPhysicalDeviceSubgroupProperties(
@@ -26600,6 +32600,213 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
+            reservedunmarshal_VkPhysicalDeviceVulkan13Features(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceVulkan13Features*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: {
+            reservedunmarshal_VkPhysicalDeviceVulkan13Properties(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceVulkan13Properties*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: {
+            reservedunmarshal_VkPipelineCreationFeedbackCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineCreationFeedbackCreateInfo*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
+            reservedunmarshal_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
+            reservedunmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
+            reservedunmarshal_VkPhysicalDevicePrivateDataFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePrivateDataFeatures*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: {
+            reservedunmarshal_VkDevicePrivateDataCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkDevicePrivateDataCreateInfo*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
+            reservedunmarshal_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: {
+            reservedunmarshal_VkMemoryBarrier2(
+                vkStream, rootType, reinterpret_cast<VkMemoryBarrier2*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
+            reservedunmarshal_VkPhysicalDeviceSynchronization2Features(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceSynchronization2Features*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
+            reservedunmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
+            reservedunmarshal_VkPhysicalDeviceImageRobustnessFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceImageRobustnessFeatures*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
+            reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeatures*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
+            reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlProperties(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlProperties*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: {
+            reservedunmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
+            reservedunmarshal_VkPhysicalDeviceInlineUniformBlockFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeatures*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
+            reservedunmarshal_VkPhysicalDeviceInlineUniformBlockProperties(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockProperties*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: {
+            reservedunmarshal_VkWriteDescriptorSetInlineUniformBlock(
+                vkStream, rootType,
+                reinterpret_cast<VkWriteDescriptorSetInlineUniformBlock*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: {
+            reservedunmarshal_VkDescriptorPoolInlineUniformBlockCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
+            reservedunmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: {
+            reservedunmarshal_VkPipelineRenderingCreateInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineRenderingCreateInfo*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
+            reservedunmarshal_VkPhysicalDeviceDynamicRenderingFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeatures*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: {
+            reservedunmarshal_VkCommandBufferInheritanceRenderingInfo(
+                vkStream, rootType,
+                reinterpret_cast<VkCommandBufferInheritanceRenderingInfo*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
+            reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
+            reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductProperties(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductProperties*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
+            reservedunmarshal_VkPhysicalDeviceTexelBufferAlignmentProperties(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentProperties*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
+            reservedunmarshal_VkFormatProperties3(
+                vkStream, rootType, reinterpret_cast<VkFormatProperties3*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
+            reservedunmarshal_VkPhysicalDeviceMaintenance4Features(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMaintenance4Features*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
+            reservedunmarshal_VkPhysicalDeviceMaintenance4Properties(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMaintenance4Properties*>(structExtension_out),
+                ptr);
+            break;
+        }
+#endif
 #ifdef VK_KHR_swapchain
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
             reservedunmarshal_VkImageSwapchainCreateInfoKHR(
@@ -26635,45 +32842,89 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
         }
 #endif
 #ifdef VK_KHR_video_queue
-        case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
-            reservedunmarshal_VkVideoQueueFamilyProperties2KHR(
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: {
+            reservedunmarshal_VkQueueFamilyQueryResultStatusPropertiesKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out), ptr);
+                reinterpret_cast<VkQueueFamilyQueryResultStatusPropertiesKHR*>(structExtension_out),
+                ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
-            reservedunmarshal_VkVideoProfileKHR(
-                vkStream, rootType, reinterpret_cast<VkVideoProfileKHR*>(structExtension_out), ptr);
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: {
+            reservedunmarshal_VkQueueFamilyVideoPropertiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkQueueFamilyVideoPropertiesKHR*>(structExtension_out), ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
-            reservedunmarshal_VkVideoProfilesKHR(
-                vkStream, rootType, reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out),
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: {
+            reservedunmarshal_VkVideoProfileInfoKHR(
+                vkStream, rootType, reinterpret_cast<VkVideoProfileInfoKHR*>(structExtension_out),
                 ptr);
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: {
+            reservedunmarshal_VkVideoProfileListInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoProfileListInfoKHR*>(structExtension_out), ptr);
+            break;
+        }
 #endif
-#ifdef VK_KHR_dynamic_rendering
-        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
-            reservedunmarshal_VkPipelineRenderingCreateInfoKHR(
+#ifdef VK_KHR_video_decode_queue
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: {
+            reservedunmarshal_VkVideoDecodeCapabilitiesKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out), ptr);
+                reinterpret_cast<VkVideoDecodeCapabilitiesKHR*>(structExtension_out), ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
-            reservedunmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: {
+            reservedunmarshal_VkVideoDecodeUsageInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(structExtension_out),
+                reinterpret_cast<VkVideoDecodeUsageInfoKHR*>(structExtension_out), ptr);
+            break;
+        }
+#endif
+#ifdef VK_KHR_video_decode_h264
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: {
+            reservedunmarshal_VkVideoDecodeH264ProfileInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH264ProfileInfoKHR*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: {
+            reservedunmarshal_VkVideoDecodeH264CapabilitiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH264CapabilitiesKHR*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            reservedunmarshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoKHR*>(
+                    structExtension_out),
                 ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
-            reservedunmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            reservedunmarshal_VkVideoDecodeH264SessionParametersCreateInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out),
+                reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoKHR*>(
+                    structExtension_out),
                 ptr);
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: {
+            reservedunmarshal_VkVideoDecodeH264PictureInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH264PictureInfoKHR*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: {
+            reservedunmarshal_VkVideoDecodeH264DpbSlotInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH264DpbSlotInfoKHR*>(structExtension_out), ptr);
+            break;
+        }
+#endif
+#ifdef VK_KHR_dynamic_rendering
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
             reservedunmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
                 vkStream, rootType,
@@ -26811,6 +33062,7 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
         }
 #endif
 #ifdef VK_KHR_portability_subset
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
             reservedunmarshal_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
                 vkStream, rootType,
@@ -26819,6 +33071,8 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
                 ptr);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
             reservedunmarshal_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
                 vkStream, rootType,
@@ -26827,6 +33081,7 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
                 ptr);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_shader_clock
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
@@ -26837,15 +33092,71 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_KHR_shader_terminate_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
-            reservedunmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+#ifdef VK_KHR_video_decode_h265
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: {
+            reservedunmarshal_VkVideoDecodeH265ProfileInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH265ProfileInfoKHR*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: {
+            reservedunmarshal_VkVideoDecodeH265CapabilitiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH265CapabilitiesKHR*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            reservedunmarshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoKHR*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            reservedunmarshal_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoKHR*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: {
+            reservedunmarshal_VkVideoDecodeH265PictureInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH265PictureInfoKHR*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: {
+            reservedunmarshal_VkVideoDecodeH265DpbSlotInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoDecodeH265DpbSlotInfoKHR*>(structExtension_out), ptr);
+            break;
+        }
+#endif
+#ifdef VK_KHR_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: {
+            reservedunmarshal_VkDeviceQueueGlobalPriorityCreateInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+                reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: {
+            reservedunmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(
                     structExtension_out),
                 ptr);
             break;
         }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: {
+            reservedunmarshal_VkQueueFamilyGlobalPriorityPropertiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesKHR*>(structExtension_out),
+                ptr);
+            break;
+        }
 #endif
 #ifdef VK_KHR_fragment_shading_rate
         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
@@ -26907,21 +33218,11 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
-            reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
-                    structExtension_out),
-                ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
-            reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+#ifdef VK_KHR_pipeline_library
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+            reservedunmarshal_VkPipelineLibraryCreateInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
-                    structExtension_out),
-                ptr);
+                reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(structExtension_out), ptr);
             break;
         }
 #endif
@@ -26939,27 +33240,49 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
         }
 #endif
 #ifdef VK_KHR_video_encode_queue
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
-            reservedunmarshal_VkVideoEncodeRateControlInfoKHR(
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: {
+            reservedunmarshal_VkVideoEncodeCapabilitiesKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out), ptr);
+                reinterpret_cast<VkVideoEncodeCapabilitiesKHR*>(structExtension_out), ptr);
             break;
         }
-#endif
-#ifdef VK_KHR_synchronization2
-        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
-            reservedunmarshal_VkMemoryBarrier2KHR(
-                vkStream, rootType, reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out),
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: {
+            reservedunmarshal_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(structExtension_out),
                 ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
-            reservedunmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: {
+            reservedunmarshal_VkVideoEncodeUsageInfoKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(structExtension_out),
-                ptr);
+                reinterpret_cast<VkVideoEncodeUsageInfoKHR*>(structExtension_out), ptr);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: {
+            reservedunmarshal_VkVideoEncodeRateControlLayerInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR*>(structExtension_out), ptr);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
+            reservedunmarshal_VkVideoEncodeRateControlInfoKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out), ptr);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#endif
+#ifdef VK_KHR_synchronization2
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
             reservedunmarshal_VkQueueFamilyCheckpointProperties2NV(
                 vkStream, rootType,
@@ -26967,21 +33290,29 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_KHR_shader_subgroup_uniform_control_flow
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
-            reservedunmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+#ifdef VK_KHR_fragment_shader_barycentric
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
+            reservedunmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
+                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: {
+            reservedunmarshal_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(
                     structExtension_out),
                 ptr);
             break;
         }
 #endif
-#ifdef VK_KHR_zero_initialize_workgroup_memory
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
-            reservedunmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
+#ifdef VK_KHR_shader_subgroup_uniform_control_flow
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
+            reservedunmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
+                reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
                     structExtension_out),
                 ptr);
             break;
@@ -26997,26 +33328,22 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_KHR_format_feature_flags2
-        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
-            reservedunmarshal_VkFormatProperties3KHR(
-                vkStream, rootType, reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out),
-                ptr);
-            break;
-        }
-#endif
-#ifdef VK_KHR_maintenance4
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
-            reservedunmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
+#ifdef VK_KHR_ray_tracing_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
+            reservedunmarshal_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out),
+                reinterpret_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
+                    structExtension_out),
                 ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
-            reservedunmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
+            reservedunmarshal_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out),
+                reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(
+                    structExtension_out),
                 ptr);
             break;
         }
@@ -27097,18 +33424,15 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
         }
 #endif
 #ifdef VK_EXT_video_encode_h264
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
             reservedunmarshal_VkVideoEncodeH264CapabilitiesEXT(
                 vkStream, rootType,
                 reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out), ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
-            reservedunmarshal_VkVideoEncodeH264SessionCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out), ptr);
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
             reservedunmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
                 vkStream, rootType,
@@ -27117,6 +33441,8 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
                 ptr);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             reservedunmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
                 vkStream, rootType,
@@ -27125,39 +33451,59 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
                 ptr);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
             reservedunmarshal_VkVideoEncodeH264VclFrameInfoEXT(
                 vkStream, rootType,
                 reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out), ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
-            reservedunmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: {
+            reservedunmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out),
-                ptr);
+                reinterpret_cast<VkVideoEncodeH264DpbSlotInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: {
+            reservedunmarshal_VkVideoEncodeH264ProfileInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoEncodeH264ProfileInfoEXT*>(structExtension_out), ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
-            reservedunmarshal_VkVideoEncodeH264ProfileEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: {
+            reservedunmarshal_VkVideoEncodeH264RateControlInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out), ptr);
+                reinterpret_cast<VkVideoEncodeH264RateControlInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: {
+            reservedunmarshal_VkVideoEncodeH264RateControlLayerInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoEXT*>(structExtension_out),
+                ptr);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_EXT_video_encode_h265
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
             reservedunmarshal_VkVideoEncodeH265CapabilitiesEXT(
                 vkStream, rootType,
                 reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out), ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
-            reservedunmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out), ptr);
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
             reservedunmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
                 vkStream, rootType,
@@ -27166,6 +33512,8 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
                 ptr);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             reservedunmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
                 vkStream, rootType,
@@ -27174,79 +33522,48 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
                 ptr);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
             reservedunmarshal_VkVideoEncodeH265VclFrameInfoEXT(
                 vkStream, rootType,
                 reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out), ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
-            reservedunmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out),
-                ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
-            reservedunmarshal_VkVideoEncodeH265ProfileEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: {
+            reservedunmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out), ptr);
+                reinterpret_cast<VkVideoEncodeH265DpbSlotInfoEXT*>(structExtension_out), ptr);
             break;
         }
-#endif
-#ifdef VK_EXT_video_decode_h264
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
-            reservedunmarshal_VkVideoDecodeH264ProfileEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: {
+            reservedunmarshal_VkVideoEncodeH265ProfileInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out), ptr);
+                reinterpret_cast<VkVideoEncodeH265ProfileInfoEXT*>(structExtension_out), ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
-            reservedunmarshal_VkVideoDecodeH264CapabilitiesEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: {
+            reservedunmarshal_VkVideoEncodeH265RateControlInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out), ptr);
+                reinterpret_cast<VkVideoEncodeH265RateControlInfoEXT*>(structExtension_out), ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
-            reservedunmarshal_VkVideoDecodeH264SessionCreateInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: {
+            reservedunmarshal_VkVideoEncodeH265RateControlLayerInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out), ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            reservedunmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(
-                    structExtension_out),
+                reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoEXT*>(structExtension_out),
                 ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            reservedunmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
-                    structExtension_out),
-                ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
-            reservedunmarshal_VkVideoDecodeH264PictureInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out), ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
-            reservedunmarshal_VkVideoDecodeH264MvcEXT(
-                vkStream, rootType, reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out),
-                ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
-            reservedunmarshal_VkVideoDecodeH264DpbSlotInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out), ptr);
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
@@ -27310,16 +33627,6 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_EXT_texture_compression_astc_hdr
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
-            reservedunmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
-                    structExtension_out),
-                ptr);
-            break;
-        }
-#endif
 #ifdef VK_EXT_astc_decode_mode
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
             reservedunmarshal_VkImageViewASTCDecodeModeEXT(
@@ -27334,6 +33641,30 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_robustness
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: {
+            reservedunmarshal_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: {
+            reservedunmarshal_VkPipelineRobustnessCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineRobustnessCreateInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+#endif
 #ifdef VK_EXT_conditional_rendering
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
             reservedunmarshal_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
@@ -27450,6 +33781,12 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
         }
 #endif
 #ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+            reservedunmarshal_VkDebugUtilsObjectNameInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
             reservedunmarshal_VkDebugUtilsMessengerCreateInfoEXT(
                 vkStream, rootType,
@@ -27494,39 +33831,6 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_EXT_inline_uniform_block
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
-            reservedunmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
-                    structExtension_out),
-                ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
-            reservedunmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
-                    structExtension_out),
-                ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
-            reservedunmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out),
-                ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
-            reservedunmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
-                    structExtension_out),
-                ptr);
-            break;
-        }
-#endif
 #ifdef VK_EXT_sample_locations
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
             reservedunmarshal_VkSampleLocationsInfoEXT(
@@ -27749,15 +34053,6 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
-            reservedunmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out),
-                ptr);
-            break;
-        }
-#endif
 #ifdef VK_EXT_external_memory_host
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
             reservedunmarshal_VkImportMemoryHostPointerInfoEXT(
@@ -27792,54 +34087,6 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_EXT_video_decode_h265
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
-            reservedunmarshal_VkVideoDecodeH265ProfileEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out), ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
-            reservedunmarshal_VkVideoDecodeH265CapabilitiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out), ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
-            reservedunmarshal_VkVideoDecodeH265SessionCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out), ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            reservedunmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(
-                    structExtension_out),
-                ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            reservedunmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
-                    structExtension_out),
-                ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
-            reservedunmarshal_VkVideoDecodeH265PictureInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out), ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
-            reservedunmarshal_VkVideoDecodeH265DpbSlotInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out), ptr);
-            break;
-        }
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
             reservedunmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
@@ -27883,15 +34130,6 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_EXT_pipeline_creation_feedback
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
-            reservedunmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out),
-                ptr);
-            break;
-        }
-#endif
 #ifdef VK_NV_compute_shader_derivatives
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
             reservedunmarshal_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
@@ -27917,16 +34155,6 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_NV_fragment_shader_barycentric
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
-            reservedunmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
-                    structExtension_out),
-                ptr);
-            break;
-        }
-#endif
 #ifdef VK_NV_shader_image_footprint
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
             reservedunmarshal_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -28105,32 +34333,6 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_EXT_subgroup_size_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
-            reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
-                    structExtension_out),
-                ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
-            reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
-                    structExtension_out),
-                ptr);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
-            reservedunmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
-                    structExtension_out),
-                ptr);
-            break;
-        }
-#endif
 #ifdef VK_AMD_shader_core_properties2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
             reservedunmarshal_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -28383,15 +34585,61 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
-            reservedunmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: {
+            reservedunmarshal_VkSurfacePresentModeEXT(
+                vkStream, rootType, reinterpret_cast<VkSurfacePresentModeEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
+            reservedunmarshal_VkSurfacePresentScalingCapabilitiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
+            reservedunmarshal_VkSurfacePresentModeCompatibilityEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+                reinterpret_cast<VkSurfacePresentModeCompatibilityEXT*>(structExtension_out), ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(
                     structExtension_out),
                 ptr);
             break;
         }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: {
+            reservedunmarshal_VkSwapchainPresentFenceInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSwapchainPresentFenceInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: {
+            reservedunmarshal_VkSwapchainPresentModesCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSwapchainPresentModesCreateInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: {
+            reservedunmarshal_VkSwapchainPresentModeInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSwapchainPresentModeInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: {
+            reservedunmarshal_VkSwapchainPresentScalingCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSwapchainPresentScalingCreateInfoEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
 #endif
 #ifdef VK_NV_device_generated_commands
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
@@ -28445,14 +34693,6 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
                 ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
-            reservedunmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-                vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
-                    structExtension_out),
-                ptr);
-            break;
-        }
 #endif
 #ifdef VK_QCOM_render_pass_transform
         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
@@ -28528,28 +34768,24 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_EXT_private_data
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
-            reservedunmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
+#ifdef VK_NV_present_barrier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
+            reservedunmarshal_VkPhysicalDevicePresentBarrierFeaturesNV(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out),
+                reinterpret_cast<VkPhysicalDevicePresentBarrierFeaturesNV*>(structExtension_out),
                 ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
-            reservedunmarshal_VkDevicePrivateDataCreateInfoEXT(
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: {
+            reservedunmarshal_VkSurfaceCapabilitiesPresentBarrierNV(
                 vkStream, rootType,
-                reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out), ptr);
+                reinterpret_cast<VkSurfaceCapabilitiesPresentBarrierNV*>(structExtension_out), ptr);
             break;
         }
-#endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
-            reservedunmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: {
+            reservedunmarshal_VkSwapchainPresentBarrierCreateInfoNV(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
-                    structExtension_out),
-                ptr);
+                reinterpret_cast<VkSwapchainPresentBarrierCreateInfoNV*>(structExtension_out), ptr);
             break;
         }
 #endif
@@ -28568,6 +34804,157 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
+#ifdef VK_NV_low_latency
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: {
+            reservedunmarshal_VkQueryLowLatencySupportNV(
+                vkStream, rootType,
+                reinterpret_cast<VkQueryLowLatencySupportNV*>(structExtension_out), ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_metal_objects
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: {
+            reservedunmarshal_VkExportMetalObjectCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalObjectCreateInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: {
+            reservedunmarshal_VkExportMetalDeviceInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalDeviceInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: {
+            reservedunmarshal_VkExportMetalCommandQueueInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalCommandQueueInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: {
+            reservedunmarshal_VkExportMetalBufferInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalBufferInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: {
+            reservedunmarshal_VkImportMetalBufferInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImportMetalBufferInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: {
+            reservedunmarshal_VkExportMetalTextureInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalTextureInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: {
+            reservedunmarshal_VkImportMetalTextureInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImportMetalTextureInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: {
+            reservedunmarshal_VkExportMetalIOSurfaceInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalIOSurfaceInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: {
+            reservedunmarshal_VkImportMetalIOSurfaceInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImportMetalIOSurfaceInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            reservedunmarshal_VkExportMetalSharedEventInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkExportMetalSharedEventInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            reservedunmarshal_VkImportMetalSharedEventInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImportMetalSharedEventInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: {
+            reservedunmarshal_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: {
+            reservedunmarshal_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: {
+            reservedunmarshal_VkGraphicsPipelineLibraryCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkGraphicsPipelineLibraryCreateInfoEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
+            reservedunmarshal_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
             reservedunmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -28654,11 +35041,34 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_EXT_image_robustness
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
-            reservedunmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+#ifdef VK_EXT_image_compression_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
+            reservedunmarshal_VkImageCompressionControlEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImageCompressionControlEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
+            reservedunmarshal_VkImageCompressionPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImageCompressionPropertiesEXT*>(structExtension_out), ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out),
+                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(
+                    structExtension_out),
                 ptr);
             break;
         }
@@ -28672,6 +35082,24 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
+#ifdef VK_EXT_device_fault
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceFaultFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceFaultFeaturesEXT*>(structExtension_out), ptr);
+            break;
+        }
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
 #ifdef VK_EXT_rgba10x6_formats
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
             reservedunmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
@@ -28682,19 +35110,18 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
         }
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
-            reservedunmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+                reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(
                     structExtension_out),
                 ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
-            reservedunmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
+        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: {
+            reservedunmarshal_VkMutableDescriptorTypeCreateInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out),
-                ptr);
+                reinterpret_cast<VkMutableDescriptorTypeCreateInfoEXT*>(structExtension_out), ptr);
             break;
         }
 #endif
@@ -28716,6 +35143,39 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
+#ifdef VK_EXT_device_address_binding_report
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: {
+            reservedunmarshal_VkDeviceAddressBindingCallbackDataEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT*>(structExtension_out), ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clip_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: {
+            reservedunmarshal_VkPipelineViewportDepthClipControlCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
             reservedunmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
@@ -28801,6 +35261,39 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: {
+            reservedunmarshal_VkSubpassResolvePerformanceQueryEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkSubpassResolvePerformanceQueryEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: {
+            reservedunmarshal_VkMultisampledRenderToSingleSampledInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkMultisampledRenderToSingleSampledInfoEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
             reservedunmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
@@ -28826,6 +35319,16 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
+#ifdef VK_EXT_primitives_generated_query
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
 #ifdef VK_GOOGLE_gfxstream
         case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
             reservedunmarshal_VkImportColorBufferGOOGLE(
@@ -28846,20 +35349,18 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority_query
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
-            reservedunmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+#ifdef VK_EXT_image_view_min_lod
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
-                    structExtension_out),
+                reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(structExtension_out),
                 ptr);
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
-            reservedunmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: {
+            reservedunmarshal_VkImageViewMinLodCreateInfoEXT(
                 vkStream, rootType,
-                reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out),
-                ptr);
+                reinterpret_cast<VkImageViewMinLodCreateInfoEXT*>(structExtension_out), ptr);
             break;
         }
 #endif
@@ -28878,6 +35379,107 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_tile_image
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderTileImagePropertiesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: {
+            reservedunmarshal_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_NV_displacement_micromap
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
+            reservedunmarshal_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: {
+            reservedunmarshal_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: {
+            reservedunmarshal_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+                vkStream, rootType,
+                reinterpret_cast<VkAccelerationStructureTrianglesDisplacementMicromapNV*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
+            reservedunmarshal_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: {
+            reservedunmarshal_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
 #ifdef VK_EXT_border_color_swizzle
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
             reservedunmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
@@ -28906,6 +35508,419 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
+#ifdef VK_ARM_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: {
+            reservedunmarshal_VkPhysicalDeviceShaderCorePropertiesARM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesARM*>(structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: {
+            reservedunmarshal_VkImageViewSlicedCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkImageViewSlicedCreateInfoEXT*>(structExtension_out), ptr);
+            break;
+        }
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
+            reservedunmarshal_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: {
+            reservedunmarshal_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: {
+            reservedunmarshal_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: {
+            reservedunmarshal_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_NV_copy_memory_indirect
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
+            reservedunmarshal_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: {
+            reservedunmarshal_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_NV_memory_decompression
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: {
+            reservedunmarshal_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: {
+            reservedunmarshal_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_NV_linear_color_attachment
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
+            reservedunmarshal_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_QCOM_image_processing
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: {
+            reservedunmarshal_VkImageViewSampleWeightCreateInfoQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkImageViewSampleWeightCreateInfoQCOM*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
+            reservedunmarshal_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: {
+            reservedunmarshal_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceImageProcessingPropertiesQCOM*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: {
+            reservedunmarshal_VkRenderPassCreationControlEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkRenderPassCreationControlEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+            reservedunmarshal_VkRenderPassCreationFeedbackCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkRenderPassCreationFeedbackCreateInfoEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: {
+            reservedunmarshal_VkRenderPassSubpassFeedbackCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkRenderPassSubpassFeedbackCreateInfoEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: {
+            reservedunmarshal_VkDirectDriverLoadingListLUNARG(
+                vkStream, rootType,
+                reinterpret_cast<VkDirectDriverLoadingListLUNARG*>(structExtension_out), ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_module_identifier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: {
+            reservedunmarshal_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_NV_optical_flow
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
+            reservedunmarshal_VkPhysicalDeviceOpticalFlowFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceOpticalFlowFeaturesNV*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: {
+            reservedunmarshal_VkPhysicalDeviceOpticalFlowPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceOpticalFlowPropertiesNV*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: {
+            reservedunmarshal_VkOpticalFlowImageFormatInfoNV(
+                vkStream, rootType,
+                reinterpret_cast<VkOpticalFlowImageFormatInfoNV*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: {
+            reservedunmarshal_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+                vkStream, rootType,
+                reinterpret_cast<VkOpticalFlowSessionCreatePrivateDataInfoNV*>(structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_legacy_dithering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_object
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceShaderObjectFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderObjectFeaturesEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceShaderObjectPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderObjectPropertiesEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_QCOM_tile_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
+            reservedunmarshal_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_SEC_amigo_profiling
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
+            reservedunmarshal_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: {
+            reservedunmarshal_VkAmigoProfilingSubmitInfoSEC(
+                vkStream, rootType,
+                reinterpret_cast<VkAmigoProfilingSubmitInfoSEC*>(structExtension_out), ptr);
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
+            reservedunmarshal_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: {
+            reservedunmarshal_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
+            reservedunmarshal_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_ARM_shader_core_builtins
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
+            reservedunmarshal_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: {
+            reservedunmarshal_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
+            reservedunmarshal_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: {
+            reservedunmarshal_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+                vkStream, rootType,
+                reinterpret_cast<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(
+                    structExtension_out),
+                ptr);
+            break;
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
             reservedunmarshal_VkWriteDescriptorSetAccelerationStructureKHR(
@@ -28958,6 +35973,21 @@ void reservedunmarshal_extension_struct(VulkanStream* vkStream, VkStructureType
             break;
         }
 #endif
+#ifdef VK_EXT_mesh_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceMeshShaderFeaturesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(structExtension_out), ptr);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: {
+            reservedunmarshal_VkPhysicalDeviceMeshShaderPropertiesEXT(
+                vkStream, rootType,
+                reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesEXT*>(structExtension_out),
+                ptr);
+            break;
+        }
+#endif
         default: {
             // fatal; the switch is only taken if the extension struct is known
             abort();
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h b/stream-servers/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
index 1b9e95e1..a40dba54 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_reserved_marshaling
 //
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (header) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -912,6 +912,206 @@ void reservedunmarshal_VkDeviceMemoryOpaqueCaptureAddressInfo(
     VkDeviceMemoryOpaqueCaptureAddressInfo* forUnmarshaling, uint8_t** ptr);
 
 #endif
+#ifdef VK_VERSION_1_3
+void reservedunmarshal_VkPhysicalDeviceVulkan13Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceVulkan13Features* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceVulkan13Properties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceVulkan13Properties* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPipelineCreationFeedback(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkPipelineCreationFeedback* forUnmarshaling,
+                                                  uint8_t** ptr);
+
+void reservedunmarshal_VkPipelineCreationFeedbackCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineCreationFeedbackCreateInfo* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderTerminateInvocationFeatures* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceToolProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceToolProperties* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDevicePrivateDataFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePrivateDataFeatures* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDevicePrivateDataCreateInfo(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkDevicePrivateDataCreateInfo* forUnmarshaling,
+                                                     uint8_t** ptr);
+
+void reservedunmarshal_VkPrivateDataSlotCreateInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkPrivateDataSlotCreateInfo* forUnmarshaling,
+                                                   uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineCreationCacheControlFeatures* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkMemoryBarrier2* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkBufferMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkBufferMemoryBarrier2* forUnmarshaling,
+                                              uint8_t** ptr);
+
+void reservedunmarshal_VkImageMemoryBarrier2(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkImageMemoryBarrier2* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDependencyInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkDependencyInfo* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkSemaphoreSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkSemaphoreSubmitInfo* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkCommandBufferSubmitInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                                 VkCommandBufferSubmitInfo* forUnmarshaling,
+                                                 uint8_t** ptr);
+
+void reservedunmarshal_VkSubmitInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkSubmitInfo2* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceSynchronization2Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSynchronization2Features* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceImageRobustnessFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageRobustnessFeatures* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkBufferCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                                     VkBufferCopy2* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkCopyBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                         VkCopyBufferInfo2* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                                    VkImageCopy2* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkCopyImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkCopyImageInfo2* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkBufferImageCopy2(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkBufferImageCopy2* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkCopyBufferToImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkCopyBufferToImageInfo2* forUnmarshaling,
+                                                uint8_t** ptr);
+
+void reservedunmarshal_VkCopyImageToBufferInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkCopyImageToBufferInfo2* forUnmarshaling,
+                                                uint8_t** ptr);
+
+void reservedunmarshal_VkImageBlit2(VulkanStream* vkStream, VkStructureType rootType,
+                                    VkImageBlit2* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkBlitImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                        VkBlitImageInfo2* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkImageResolve2(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkImageResolve2* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkResolveImageInfo2(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkResolveImageInfo2* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSubgroupSizeControlFeatures* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSubgroupSizeControlProperties* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceInlineUniformBlockFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceInlineUniformBlockFeatures* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceInlineUniformBlockProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceInlineUniformBlockProperties* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkWriteDescriptorSetInlineUniformBlock(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkWriteDescriptorSetInlineUniformBlock* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorPoolInlineUniformBlockCreateInfo* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkRenderingAttachmentInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                                 VkRenderingAttachmentInfo* forUnmarshaling,
+                                                 uint8_t** ptr);
+
+void reservedunmarshal_VkRenderingInfo(VulkanStream* vkStream, VkStructureType rootType,
+                                       VkRenderingInfo* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPipelineRenderingCreateInfo(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkPipelineRenderingCreateInfo* forUnmarshaling,
+                                                     uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceDynamicRenderingFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDynamicRenderingFeatures* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkCommandBufferInheritanceRenderingInfo(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkCommandBufferInheritanceRenderingInfo* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderIntegerDotProductFeatures* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderIntegerDotProductProperties* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceTexelBufferAlignmentProperties* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkFormatProperties3(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkFormatProperties3* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceMaintenance4Features(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance4Features* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceMaintenance4Properties(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMaintenance4Properties* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDeviceBufferMemoryRequirements(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceBufferMemoryRequirements* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDeviceImageMemoryRequirements(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceImageMemoryRequirements* forUnmarshaling, uint8_t** ptr);
+
+#endif
 #ifdef VK_KHR_surface
 void reservedunmarshal_VkSurfaceCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                                 VkSurfaceCapabilitiesKHR* forUnmarshaling,
@@ -1028,15 +1228,20 @@ void reservedunmarshal_VkWin32SurfaceCreateInfoKHR(VulkanStream* vkStream, VkStr
 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
 #endif
 #ifdef VK_KHR_video_queue
-void reservedunmarshal_VkVideoQueueFamilyProperties2KHR(
+void reservedunmarshal_VkQueueFamilyQueryResultStatusPropertiesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoQueueFamilyProperties2KHR* forUnmarshaling, uint8_t** ptr);
+    VkQueueFamilyQueryResultStatusPropertiesKHR* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkVideoProfileKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                         VkVideoProfileKHR* forUnmarshaling, uint8_t** ptr);
+void reservedunmarshal_VkQueueFamilyVideoPropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkQueueFamilyVideoPropertiesKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkVideoProfileInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkVideoProfileInfoKHR* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkVideoProfilesKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                          VkVideoProfilesKHR* forUnmarshaling, uint8_t** ptr);
+void reservedunmarshal_VkVideoProfileListInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                 VkVideoProfileListInfoKHR* forUnmarshaling,
+                                                 uint8_t** ptr);
 
 void reservedunmarshal_VkVideoCapabilitiesKHR(VulkanStream* vkStream, VkStructureType rootType,
                                               VkVideoCapabilitiesKHR* forUnmarshaling,
@@ -1050,21 +1255,22 @@ void reservedunmarshal_VkVideoFormatPropertiesKHR(VulkanStream* vkStream, VkStru
                                                   VkVideoFormatPropertiesKHR* forUnmarshaling,
                                                   uint8_t** ptr);
 
-void reservedunmarshal_VkVideoPictureResourceKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                 VkVideoPictureResourceKHR* forUnmarshaling,
-                                                 uint8_t** ptr);
-
-void reservedunmarshal_VkVideoReferenceSlotKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoReferenceSlotKHR* forUnmarshaling,
-                                               uint8_t** ptr);
-
-void reservedunmarshal_VkVideoGetMemoryPropertiesKHR(VulkanStream* vkStream,
+void reservedunmarshal_VkVideoPictureResourceInfoKHR(VulkanStream* vkStream,
                                                      VkStructureType rootType,
-                                                     VkVideoGetMemoryPropertiesKHR* forUnmarshaling,
+                                                     VkVideoPictureResourceInfoKHR* forUnmarshaling,
                                                      uint8_t** ptr);
 
-void reservedunmarshal_VkVideoBindMemoryKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                            VkVideoBindMemoryKHR* forUnmarshaling, uint8_t** ptr);
+void reservedunmarshal_VkVideoReferenceSlotInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkVideoReferenceSlotInfoKHR* forUnmarshaling,
+                                                   uint8_t** ptr);
+
+void reservedunmarshal_VkVideoSessionMemoryRequirementsKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoSessionMemoryRequirementsKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkBindVideoSessionMemoryInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkBindVideoSessionMemoryInfoKHR* forUnmarshaling, uint8_t** ptr);
 
 void reservedunmarshal_VkVideoSessionCreateInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                                    VkVideoSessionCreateInfoKHR* forUnmarshaling,
@@ -1092,30 +1298,59 @@ void reservedunmarshal_VkVideoCodingControlInfoKHR(VulkanStream* vkStream, VkStr
 
 #endif
 #ifdef VK_KHR_video_decode_queue
+void reservedunmarshal_VkVideoDecodeCapabilitiesKHR(VulkanStream* vkStream,
+                                                    VkStructureType rootType,
+                                                    VkVideoDecodeCapabilitiesKHR* forUnmarshaling,
+                                                    uint8_t** ptr);
+
+void reservedunmarshal_VkVideoDecodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                 VkVideoDecodeUsageInfoKHR* forUnmarshaling,
+                                                 uint8_t** ptr);
+
 void reservedunmarshal_VkVideoDecodeInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkVideoDecodeInfoKHR* forUnmarshaling, uint8_t** ptr);
 
 #endif
-#ifdef VK_KHR_dynamic_rendering
-void reservedunmarshal_VkRenderingAttachmentInfoKHR(VulkanStream* vkStream,
-                                                    VkStructureType rootType,
-                                                    VkRenderingAttachmentInfoKHR* forUnmarshaling,
-                                                    uint8_t** ptr);
+#ifdef VK_KHR_video_decode_h264
+void reservedunmarshal_VkVideoDecodeH264ProfileInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH264ProfileInfoKHR* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkRenderingInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                          VkRenderingInfoKHR* forUnmarshaling, uint8_t** ptr);
+void reservedunmarshal_VkVideoDecodeH264CapabilitiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH264CapabilitiesKHR* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkPipelineRenderingCreateInfoKHR(
+void reservedunmarshal_VkVideoDecodeH264SessionParametersAddInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPipelineRenderingCreateInfoKHR* forUnmarshaling, uint8_t** ptr);
+    VkVideoDecodeH264SessionParametersAddInfoKHR* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+void reservedunmarshal_VkVideoDecodeH264SessionParametersCreateInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceDynamicRenderingFeaturesKHR* forUnmarshaling, uint8_t** ptr);
+    VkVideoDecodeH264SessionParametersCreateInfoKHR* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkCommandBufferInheritanceRenderingInfoKHR(
+void reservedunmarshal_VkVideoDecodeH264PictureInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkCommandBufferInheritanceRenderingInfoKHR* forUnmarshaling, uint8_t** ptr);
+    VkVideoDecodeH264PictureInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkVideoDecodeH264DpbSlotInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH264DpbSlotInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_KHR_dynamic_rendering
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkRenderingInfo, reservedunmarshal_VkRenderingInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkRenderingAttachmentInfo,
+                      reservedunmarshal_VkRenderingAttachmentInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPipelineRenderingCreateInfo,
+                      reservedunmarshal_VkPipelineRenderingCreateInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceDynamicRenderingFeatures,
+                      reservedunmarshal_VkPhysicalDeviceDynamicRenderingFeaturesKHR)
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkCommandBufferInheritanceRenderingInfo,
+                      reservedunmarshal_VkCommandBufferInheritanceRenderingInfoKHR)
 
 void reservedunmarshal_VkRenderingFragmentShadingRateAttachmentInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -1638,6 +1873,46 @@ void reservedunmarshal_VkPhysicalDeviceShaderClockFeaturesKHR(
     VkPhysicalDeviceShaderClockFeaturesKHR* forUnmarshaling, uint8_t** ptr);
 
 #endif
+#ifdef VK_KHR_video_decode_h265
+void reservedunmarshal_VkVideoDecodeH265ProfileInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265ProfileInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkVideoDecodeH265CapabilitiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265CapabilitiesKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265SessionParametersAddInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265SessionParametersCreateInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkVideoDecodeH265PictureInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265PictureInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkVideoDecodeH265DpbSlotInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoDecodeH265DpbSlotInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_KHR_global_priority
+void reservedunmarshal_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceQueueGlobalPriorityCreateInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkQueueFamilyGlobalPriorityPropertiesKHR* forUnmarshaling, uint8_t** ptr);
+
+#endif
 #ifdef VK_KHR_driver_properties
 DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkConformanceVersion,
                       reservedunmarshal_VkConformanceVersionKHR)
@@ -1687,9 +1962,8 @@ DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceVulkanMemoryModelFeature
 
 #endif
 #ifdef VK_KHR_shader_terminate_invocation
-void reservedunmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceShaderTerminateInvocationFeatures,
+                      reservedunmarshal_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)
 
 #endif
 #ifdef VK_KHR_fragment_shading_rate
@@ -1792,14 +2066,20 @@ void reservedunmarshal_VkPipelineExecutableInternalRepresentationKHR(
     VkPipelineExecutableInternalRepresentationKHR* forUnmarshaling, uint8_t** ptr);
 
 #endif
+#ifdef VK_KHR_map_memory2
+void reservedunmarshal_VkMemoryMapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkMemoryMapInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkMemoryUnmapInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                            VkMemoryUnmapInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
-void reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductFeatures,
+                      reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR)
 
-void reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductProperties,
+                      reservedunmarshal_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)
 
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -1823,41 +2103,49 @@ void reservedunmarshal_VkPhysicalDevicePresentIdFeaturesKHR(
 void reservedunmarshal_VkVideoEncodeInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
                                             VkVideoEncodeInfoKHR* forUnmarshaling, uint8_t** ptr);
 
+void reservedunmarshal_VkVideoEncodeCapabilitiesKHR(VulkanStream* vkStream,
+                                                    VkStructureType rootType,
+                                                    VkVideoEncodeCapabilitiesKHR* forUnmarshaling,
+                                                    uint8_t** ptr);
+
+void reservedunmarshal_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkVideoEncodeUsageInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                 VkVideoEncodeUsageInfoKHR* forUnmarshaling,
+                                                 uint8_t** ptr);
+
+void reservedunmarshal_VkVideoEncodeRateControlLayerInfoKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeRateControlLayerInfoKHR* forUnmarshaling, uint8_t** ptr);
+
 void reservedunmarshal_VkVideoEncodeRateControlInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
     VkVideoEncodeRateControlInfoKHR* forUnmarshaling, uint8_t** ptr);
 
 #endif
 #ifdef VK_KHR_synchronization2
-void reservedunmarshal_VkMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkMemoryBarrier2KHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkMemoryBarrier2, reservedunmarshal_VkMemoryBarrier2KHR)
 
-void reservedunmarshal_VkBufferMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                 VkBufferMemoryBarrier2KHR* forUnmarshaling,
-                                                 uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkBufferMemoryBarrier2,
+                      reservedunmarshal_VkBufferMemoryBarrier2KHR)
 
-void reservedunmarshal_VkImageMemoryBarrier2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkImageMemoryBarrier2KHR* forUnmarshaling,
-                                                uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkImageMemoryBarrier2,
+                      reservedunmarshal_VkImageMemoryBarrier2KHR)
 
-void reservedunmarshal_VkDependencyInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkDependencyInfoKHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkDependencyInfo, reservedunmarshal_VkDependencyInfoKHR)
 
-void reservedunmarshal_VkSemaphoreSubmitInfoKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkSemaphoreSubmitInfoKHR* forUnmarshaling,
-                                                uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkSubmitInfo2, reservedunmarshal_VkSubmitInfo2KHR)
 
-void reservedunmarshal_VkCommandBufferSubmitInfoKHR(VulkanStream* vkStream,
-                                                    VkStructureType rootType,
-                                                    VkCommandBufferSubmitInfoKHR* forUnmarshaling,
-                                                    uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkSemaphoreSubmitInfo,
+                      reservedunmarshal_VkSemaphoreSubmitInfoKHR)
 
-void reservedunmarshal_VkSubmitInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                        VkSubmitInfo2KHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkCommandBufferSubmitInfo,
+                      reservedunmarshal_VkCommandBufferSubmitInfoKHR)
 
-void reservedunmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceSynchronization2FeaturesKHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceSynchronization2Features,
+                      reservedunmarshal_VkPhysicalDeviceSynchronization2FeaturesKHR)
 
 void reservedunmarshal_VkQueueFamilyCheckpointProperties2NV(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -1867,6 +2155,16 @@ void reservedunmarshal_VkCheckpointData2NV(VulkanStream* vkStream, VkStructureTy
                                            VkCheckpointData2NV* forUnmarshaling, uint8_t** ptr);
 
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+void reservedunmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* forUnmarshaling, uint8_t** ptr);
+
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 void reservedunmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -1874,9 +2172,8 @@ void reservedunmarshal_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesK
 
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
-void reservedunmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
+                      reservedunmarshal_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR)
 
 #endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
@@ -1886,71 +2183,85 @@ void reservedunmarshal_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_copy_commands2
-void reservedunmarshal_VkBufferCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                        VkBufferCopy2KHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkCopyBufferInfo2, reservedunmarshal_VkCopyBufferInfo2KHR)
 
-void reservedunmarshal_VkCopyBufferInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                            VkCopyBufferInfo2KHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkCopyImageInfo2, reservedunmarshal_VkCopyImageInfo2KHR)
 
-void reservedunmarshal_VkImageCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                       VkImageCopy2KHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkCopyBufferToImageInfo2,
+                      reservedunmarshal_VkCopyBufferToImageInfo2KHR)
 
-void reservedunmarshal_VkCopyImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkCopyImageInfo2KHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkCopyImageToBufferInfo2,
+                      reservedunmarshal_VkCopyImageToBufferInfo2KHR)
 
-void reservedunmarshal_VkBufferImageCopy2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                             VkBufferImageCopy2KHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkBlitImageInfo2, reservedunmarshal_VkBlitImageInfo2KHR)
 
-void reservedunmarshal_VkCopyBufferToImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                   VkCopyBufferToImageInfo2KHR* forUnmarshaling,
-                                                   uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkResolveImageInfo2,
+                      reservedunmarshal_VkResolveImageInfo2KHR)
 
-void reservedunmarshal_VkCopyImageToBufferInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                   VkCopyImageToBufferInfo2KHR* forUnmarshaling,
-                                                   uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkBufferCopy2, reservedunmarshal_VkBufferCopy2KHR)
 
-void reservedunmarshal_VkImageBlit2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                       VkImageBlit2KHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkImageCopy2, reservedunmarshal_VkImageCopy2KHR)
 
-void reservedunmarshal_VkBlitImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                           VkBlitImageInfo2KHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkImageBlit2, reservedunmarshal_VkImageBlit2KHR)
 
-void reservedunmarshal_VkImageResolve2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                          VkImageResolve2KHR* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkBufferImageCopy2, reservedunmarshal_VkBufferImageCopy2KHR)
 
-void reservedunmarshal_VkResolveImageInfo2KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                              VkResolveImageInfo2KHR* forUnmarshaling,
-                                              uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkImageResolve2, reservedunmarshal_VkImageResolve2KHR)
 
 #endif
 #ifdef VK_KHR_format_feature_flags2
-void reservedunmarshal_VkFormatProperties3KHR(VulkanStream* vkStream, VkStructureType rootType,
-                                              VkFormatProperties3KHR* forUnmarshaling,
-                                              uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkFormatProperties3,
+                      reservedunmarshal_VkFormatProperties3KHR)
 
 #endif
-#ifdef VK_KHR_maintenance4
-void reservedunmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR(
+#ifdef VK_KHR_ray_tracing_maintenance1
+void reservedunmarshal_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceMaintenance4FeaturesKHR* forUnmarshaling, uint8_t** ptr);
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR(
+void reservedunmarshal_VkTraceRaysIndirectCommand2KHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceMaintenance4PropertiesKHR* forUnmarshaling, uint8_t** ptr);
+    VkTraceRaysIndirectCommand2KHR* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkDeviceBufferMemoryRequirementsKHR(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceBufferMemoryRequirementsKHR* forUnmarshaling, uint8_t** ptr);
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
+#ifdef VK_KHR_maintenance4
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceMaintenance4Features,
+                      reservedunmarshal_VkPhysicalDeviceMaintenance4FeaturesKHR)
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceMaintenance4Properties,
+                      reservedunmarshal_VkPhysicalDeviceMaintenance4PropertiesKHR)
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkDeviceBufferMemoryRequirements,
+                      reservedunmarshal_VkDeviceBufferMemoryRequirementsKHR)
 
-void reservedunmarshal_VkDeviceImageMemoryRequirementsKHR(
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkDeviceImageMemoryRequirements,
+                      reservedunmarshal_VkDeviceImageMemoryRequirementsKHR)
+
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+void reservedunmarshal_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceImageMemoryRequirementsKHR* forUnmarshaling, uint8_t** ptr);
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* forUnmarshaling, uint8_t** ptr);
 
 #endif
 #ifdef VK_ANDROID_native_buffer
+void reservedunmarshal_VkNativeBufferUsage2ANDROID(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkNativeBufferUsage2ANDROID* forUnmarshaling,
+                                                   uint8_t** ptr);
+
 void reservedunmarshal_VkNativeBufferANDROID(VulkanStream* vkStream, VkStructureType rootType,
                                              VkNativeBufferANDROID* forUnmarshaling, uint8_t** ptr);
 
+void reservedunmarshal_VkSwapchainImageCreateInfoANDROID(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainImageCreateInfoANDROID* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDevicePresentationPropertiesANDROID(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePresentationPropertiesANDROID* forUnmarshaling, uint8_t** ptr);
+
 #endif
 #ifdef VK_EXT_debug_report
 void reservedunmarshal_VkDebugReportCallbackCreateInfoEXT(
@@ -2055,10 +2366,6 @@ void reservedunmarshal_VkVideoEncodeH264CapabilitiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkVideoEncodeH264CapabilitiesEXT* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkVideoEncodeH264SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH264SessionCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
-
 void reservedunmarshal_VkVideoEncodeH264SessionParametersAddInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkVideoEncodeH264SessionParametersAddInfoEXT* forUnmarshaling, uint8_t** ptr);
@@ -2067,26 +2374,38 @@ void reservedunmarshal_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkVideoEncodeH264SessionParametersCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+void reservedunmarshal_VkVideoEncodeH264NaluSliceInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH264DpbSlotInfoEXT* forUnmarshaling, uint8_t** ptr);
-
-void reservedunmarshal_VkVideoEncodeH264NaluSliceEXT(VulkanStream* vkStream,
-                                                     VkStructureType rootType,
-                                                     VkVideoEncodeH264NaluSliceEXT* forUnmarshaling,
-                                                     uint8_t** ptr);
+    VkVideoEncodeH264NaluSliceInfoEXT* forUnmarshaling, uint8_t** ptr);
 
 void reservedunmarshal_VkVideoEncodeH264VclFrameInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkVideoEncodeH264VclFrameInfoEXT* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkVideoEncodeH264EmitPictureParametersEXT(
+void reservedunmarshal_VkVideoEncodeH264DpbSlotInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH264DpbSlotInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkVideoEncodeH264ProfileInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH264EmitPictureParametersEXT* forUnmarshaling, uint8_t** ptr);
+    VkVideoEncodeH264ProfileInfoEXT* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkVideoEncodeH264ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                   VkVideoEncodeH264ProfileEXT* forUnmarshaling,
-                                                   uint8_t** ptr);
+void reservedunmarshal_VkVideoEncodeH264RateControlInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH264RateControlInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkVideoEncodeH264QpEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkVideoEncodeH264QpEXT* forUnmarshaling,
+                                              uint8_t** ptr);
+
+void reservedunmarshal_VkVideoEncodeH264FrameSizeEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkVideoEncodeH264FrameSizeEXT* forUnmarshaling,
+                                                     uint8_t** ptr);
+
+void reservedunmarshal_VkVideoEncodeH264RateControlLayerInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkVideoEncodeH264RateControlLayerInfoEXT* forUnmarshaling, uint8_t** ptr);
 
 #endif
 #ifdef VK_EXT_video_encode_h265
@@ -2094,10 +2413,6 @@ void reservedunmarshal_VkVideoEncodeH265CapabilitiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkVideoEncodeH265CapabilitiesEXT* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkVideoEncodeH265SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265SessionCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
-
 void reservedunmarshal_VkVideoEncodeH265SessionParametersAddInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkVideoEncodeH265SessionParametersAddInfoEXT* forUnmarshaling, uint8_t** ptr);
@@ -2106,64 +2421,38 @@ void reservedunmarshal_VkVideoEncodeH265SessionParametersCreateInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkVideoEncodeH265SessionParametersCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265DpbSlotInfoEXT* forUnmarshaling, uint8_t** ptr);
-
-void reservedunmarshal_VkVideoEncodeH265ReferenceListsEXT(
+void reservedunmarshal_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265ReferenceListsEXT* forUnmarshaling, uint8_t** ptr);
-
-void reservedunmarshal_VkVideoEncodeH265NaluSliceEXT(VulkanStream* vkStream,
-                                                     VkStructureType rootType,
-                                                     VkVideoEncodeH265NaluSliceEXT* forUnmarshaling,
-                                                     uint8_t** ptr);
+    VkVideoEncodeH265NaluSliceSegmentInfoEXT* forUnmarshaling, uint8_t** ptr);
 
 void reservedunmarshal_VkVideoEncodeH265VclFrameInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkVideoEncodeH265VclFrameInfoEXT* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkVideoEncodeH265EmitPictureParametersEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoEncodeH265EmitPictureParametersEXT* forUnmarshaling, uint8_t** ptr);
-
-void reservedunmarshal_VkVideoEncodeH265ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                   VkVideoEncodeH265ProfileEXT* forUnmarshaling,
-                                                   uint8_t** ptr);
-
-#endif
-#ifdef VK_EXT_video_decode_h264
-void reservedunmarshal_VkVideoDecodeH264ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                   VkVideoDecodeH264ProfileEXT* forUnmarshaling,
-                                                   uint8_t** ptr);
-
-void reservedunmarshal_VkVideoDecodeH264CapabilitiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264CapabilitiesEXT* forUnmarshaling, uint8_t** ptr);
-
-void reservedunmarshal_VkVideoDecodeH264SessionCreateInfoEXT(
+void reservedunmarshal_VkVideoEncodeH265DpbSlotInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264SessionCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+    VkVideoEncodeH265DpbSlotInfoEXT* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkVideoDecodeH264SessionParametersAddInfoEXT(
+void reservedunmarshal_VkVideoEncodeH265ProfileInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264SessionParametersAddInfoEXT* forUnmarshaling, uint8_t** ptr);
+    VkVideoEncodeH265ProfileInfoEXT* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkVideoDecodeH264SessionParametersCreateInfoEXT(
+void reservedunmarshal_VkVideoEncodeH265RateControlInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264SessionParametersCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+    VkVideoEncodeH265RateControlInfoEXT* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkVideoDecodeH264PictureInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264PictureInfoEXT* forUnmarshaling, uint8_t** ptr);
+void reservedunmarshal_VkVideoEncodeH265QpEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkVideoEncodeH265QpEXT* forUnmarshaling,
+                                              uint8_t** ptr);
 
-void reservedunmarshal_VkVideoDecodeH264MvcEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                               VkVideoDecodeH264MvcEXT* forUnmarshaling,
-                                               uint8_t** ptr);
+void reservedunmarshal_VkVideoEncodeH265FrameSizeEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkVideoEncodeH265FrameSizeEXT* forUnmarshaling,
+                                                     uint8_t** ptr);
 
-void reservedunmarshal_VkVideoDecodeH264DpbSlotInfoEXT(
+void reservedunmarshal_VkVideoEncodeH265RateControlLayerInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH264DpbSlotInfoEXT* forUnmarshaling, uint8_t** ptr);
+    VkVideoEncodeH265RateControlLayerInfoEXT* forUnmarshaling, uint8_t** ptr);
 
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
@@ -2247,9 +2536,8 @@ void reservedunmarshal_VkViSurfaceCreateInfoNN(VulkanStream* vkStream, VkStructu
 #ifdef VK_EXT_shader_subgroup_vote
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
-void reservedunmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeatures,
+                      reservedunmarshal_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
 
 #endif
 #ifdef VK_EXT_astc_decode_mode
@@ -2263,6 +2551,20 @@ void reservedunmarshal_VkPhysicalDeviceASTCDecodeFeaturesEXT(
     VkPhysicalDeviceASTCDecodeFeaturesEXT* forUnmarshaling, uint8_t** ptr);
 
 #endif
+#ifdef VK_EXT_pipeline_robustness
+void reservedunmarshal_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPipelineRobustnessCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineRobustnessCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
 #ifdef VK_EXT_conditional_rendering
 void reservedunmarshal_VkConditionalRenderingBeginInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -2402,8 +2704,6 @@ void reservedunmarshal_VkMacOSSurfaceCreateInfoMVK(VulkanStream* vkStream, VkStr
                                                    uint8_t** ptr);
 
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -2476,21 +2776,17 @@ DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceSamplerFilterMinmaxPrope
 #ifdef VK_AMD_shader_fragment_mask
 #endif
 #ifdef VK_EXT_inline_uniform_block
-void reservedunmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceInlineUniformBlockFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceInlineUniformBlockFeatures,
+                      reservedunmarshal_VkPhysicalDeviceInlineUniformBlockFeaturesEXT)
 
-void reservedunmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceInlineUniformBlockPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceInlineUniformBlockProperties,
+                      reservedunmarshal_VkPhysicalDeviceInlineUniformBlockPropertiesEXT)
 
-void reservedunmarshal_VkWriteDescriptorSetInlineUniformBlockEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkWriteDescriptorSetInlineUniformBlockEXT* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkWriteDescriptorSetInlineUniformBlock,
+                      reservedunmarshal_VkWriteDescriptorSetInlineUniformBlockEXT)
 
-void reservedunmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkDescriptorPoolInlineUniformBlockCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkDescriptorPoolInlineUniformBlockCreateInfo,
+                      reservedunmarshal_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_shader_stencil_export
@@ -2748,9 +3044,8 @@ void reservedunmarshal_VkFilterCubicImageViewImageFormatPropertiesEXT(
 #ifdef VK_QCOM_render_pass_shader_resolve
 #endif
 #ifdef VK_EXT_global_priority
-void reservedunmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkDeviceQueueGlobalPriorityCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkDeviceQueueGlobalPriorityCreateInfoKHR,
+                      reservedunmarshal_VkDeviceQueueGlobalPriorityCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_external_memory_host
@@ -2788,36 +3083,6 @@ void reservedunmarshal_VkPhysicalDeviceShaderCorePropertiesAMD(
     VkPhysicalDeviceShaderCorePropertiesAMD* forUnmarshaling, uint8_t** ptr);
 
 #endif
-#ifdef VK_EXT_video_decode_h265
-void reservedunmarshal_VkVideoDecodeH265ProfileEXT(VulkanStream* vkStream, VkStructureType rootType,
-                                                   VkVideoDecodeH265ProfileEXT* forUnmarshaling,
-                                                   uint8_t** ptr);
-
-void reservedunmarshal_VkVideoDecodeH265CapabilitiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265CapabilitiesEXT* forUnmarshaling, uint8_t** ptr);
-
-void reservedunmarshal_VkVideoDecodeH265SessionCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265SessionCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
-
-void reservedunmarshal_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265SessionParametersAddInfoEXT* forUnmarshaling, uint8_t** ptr);
-
-void reservedunmarshal_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265SessionParametersCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
-
-void reservedunmarshal_VkVideoDecodeH265PictureInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265PictureInfoEXT* forUnmarshaling, uint8_t** ptr);
-
-void reservedunmarshal_VkVideoDecodeH265DpbSlotInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkVideoDecodeH265DpbSlotInfoEXT* forUnmarshaling, uint8_t** ptr);
-
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 void reservedunmarshal_VkDeviceMemoryOverallocationCreateInfoAMD(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -2849,14 +3114,11 @@ void reservedunmarshal_VkPresentFrameTokenGGP(VulkanStream* vkStream, VkStructur
 
 #endif
 #ifdef VK_EXT_pipeline_creation_feedback
-void reservedunmarshal_VkPipelineCreationFeedbackEXT(VulkanStream* vkStream,
-                                                     VkStructureType rootType,
-                                                     VkPipelineCreationFeedbackEXT* forUnmarshaling,
-                                                     uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPipelineCreationFeedbackCreateInfo,
+                      reservedunmarshal_VkPipelineCreationFeedbackCreateInfoEXT)
 
-void reservedunmarshal_VkPipelineCreationFeedbackCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPipelineCreationFeedbackCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPipelineCreationFeedback,
+                      reservedunmarshal_VkPipelineCreationFeedbackEXT)
 
 #endif
 #ifdef VK_NV_shader_subgroup_partitioned
@@ -2882,9 +3144,8 @@ void reservedunmarshal_VkDrawMeshTasksIndirectCommandNV(
 
 #endif
 #ifdef VK_NV_fragment_shader_barycentric
-void reservedunmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
+                      reservedunmarshal_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV)
 
 #endif
 #ifdef VK_NV_shader_image_footprint
@@ -3008,17 +3269,14 @@ DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceScalarBlockLayoutFeature
 #ifdef VK_GOOGLE_decorate_string
 #endif
 #ifdef VK_EXT_subgroup_size_control
-void reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlFeatures,
+                      reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)
 
-void reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlProperties,
+                      reservedunmarshal_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT)
 
-void reservedunmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      reservedunmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)
 
 #endif
 #ifdef VK_AMD_shader_core_properties2
@@ -3078,9 +3336,8 @@ void reservedunmarshal_VkBufferDeviceAddressCreateInfoEXT(
 
 #endif
 #ifdef VK_EXT_tooling_info
-void reservedunmarshal_VkPhysicalDeviceToolPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceToolPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceToolProperties,
+                      reservedunmarshal_VkPhysicalDeviceToolPropertiesEXT)
 
 #endif
 #ifdef VK_EXT_separate_stencil_usage
@@ -3211,10 +3468,50 @@ void reservedunmarshal_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
     VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* forUnmarshaling, uint8_t** ptr);
 
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-void reservedunmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+void reservedunmarshal_VkSurfacePresentModeEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkSurfacePresentModeEXT* forUnmarshaling,
+                                               uint8_t** ptr);
+
+void reservedunmarshal_VkSurfacePresentScalingCapabilitiesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+    VkSurfacePresentScalingCapabilitiesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkSurfacePresentModeCompatibilityEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSurfacePresentModeCompatibilityEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+void reservedunmarshal_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkSwapchainPresentFenceInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainPresentFenceInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkSwapchainPresentModesCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainPresentModesCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkSwapchainPresentModeInfoEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkSwapchainPresentModeInfoEXT* forUnmarshaling,
+                                                     uint8_t** ptr);
+
+void reservedunmarshal_VkSwapchainPresentScalingCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSwapchainPresentScalingCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkReleaseSwapchainImagesInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkReleaseSwapchainImagesInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_shader_demote_to_helper_invocation
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures,
+                      reservedunmarshal_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)
 
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -3286,9 +3583,8 @@ void reservedunmarshal_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
     VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceTexelBufferAlignmentProperties,
+                      reservedunmarshal_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)
 
 #endif
 #ifdef VK_QCOM_render_pass_transform
@@ -3343,24 +3639,34 @@ void reservedunmarshal_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
-#ifdef VK_EXT_private_data
-void reservedunmarshal_VkPhysicalDevicePrivateDataFeaturesEXT(
+#ifdef VK_NV_present_barrier
+void reservedunmarshal_VkPhysicalDevicePresentBarrierFeaturesNV(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDevicePrivateDataFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+    VkPhysicalDevicePresentBarrierFeaturesNV* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkDevicePrivateDataCreateInfoEXT(
+void reservedunmarshal_VkSurfaceCapabilitiesPresentBarrierNV(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkDevicePrivateDataCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+    VkSurfaceCapabilitiesPresentBarrierNV* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkPrivateDataSlotCreateInfoEXT(
+void reservedunmarshal_VkSwapchainPresentBarrierCreateInfoNV(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPrivateDataSlotCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+    VkSwapchainPresentBarrierCreateInfoNV* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_private_data
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDevicePrivateDataFeatures,
+                      reservedunmarshal_VkPhysicalDevicePrivateDataFeaturesEXT)
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkDevicePrivateDataCreateInfo,
+                      reservedunmarshal_VkDevicePrivateDataCreateInfoEXT)
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPrivateDataSlotCreateInfo,
+                      reservedunmarshal_VkPrivateDataSlotCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
-void reservedunmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
-    VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDevicePipelineCreationCacheControlFeatures,
+                      reservedunmarshal_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT)
 
 #endif
 #ifdef VK_NV_device_diagnostics_config
@@ -3375,6 +3681,141 @@ void reservedunmarshal_VkDeviceDiagnosticsConfigCreateInfoNV(
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+void reservedunmarshal_VkQueryLowLatencySupportNV(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkQueryLowLatencySupportNV* forUnmarshaling,
+                                                  uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_metal_objects
+void reservedunmarshal_VkExportMetalObjectCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkExportMetalObjectCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkExportMetalObjectsInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkExportMetalObjectsInfoEXT* forUnmarshaling,
+                                                   uint8_t** ptr);
+
+void reservedunmarshal_VkExportMetalDeviceInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkExportMetalDeviceInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr);
+
+void reservedunmarshal_VkExportMetalCommandQueueInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkExportMetalCommandQueueInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkExportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkExportMetalBufferInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr);
+
+void reservedunmarshal_VkImportMetalBufferInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkImportMetalBufferInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr);
+
+void reservedunmarshal_VkExportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkExportMetalTextureInfoEXT* forUnmarshaling,
+                                                   uint8_t** ptr);
+
+void reservedunmarshal_VkImportMetalTextureInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkImportMetalTextureInfoEXT* forUnmarshaling,
+                                                   uint8_t** ptr);
+
+void reservedunmarshal_VkExportMetalIOSurfaceInfoEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkExportMetalIOSurfaceInfoEXT* forUnmarshaling,
+                                                     uint8_t** ptr);
+
+void reservedunmarshal_VkImportMetalIOSurfaceInfoEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkImportMetalIOSurfaceInfoEXT* forUnmarshaling,
+                                                     uint8_t** ptr);
+
+void reservedunmarshal_VkExportMetalSharedEventInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkExportMetalSharedEventInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkImportMetalSharedEventInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImportMetalSharedEventInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void reservedunmarshal_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDescriptorAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkDescriptorAddressInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr);
+
+void reservedunmarshal_VkDescriptorBufferBindingInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorBufferBindingInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDescriptorDataEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                           VkDescriptorDataEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDescriptorGetInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkDescriptorGetInfoEXT* forUnmarshaling,
+                                              uint8_t** ptr);
+
+void reservedunmarshal_VkBufferCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkBufferCaptureDescriptorDataInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkImageCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageCaptureDescriptorDataInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkImageViewCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageViewCaptureDescriptorDataInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkSamplerCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSamplerCaptureDescriptorDataInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpaqueCaptureDescriptorDataCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+void reservedunmarshal_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkGraphicsPipelineLibraryCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkGraphicsPipelineLibraryCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+void reservedunmarshal_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* forUnmarshaling, uint8_t** ptr);
+
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void reservedunmarshal_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -3450,9 +3891,37 @@ void reservedunmarshal_VkCopyCommandTransformInfoQCOM(
 
 #endif
 #ifdef VK_EXT_image_robustness
-void reservedunmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceImageRobustnessFeatures,
+                      reservedunmarshal_VkPhysicalDeviceImageRobustnessFeaturesEXT)
+
+#endif
+#ifdef VK_EXT_image_compression_control
+void reservedunmarshal_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceImageRobustnessFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkImageCompressionControlEXT(VulkanStream* vkStream,
+                                                    VkStructureType rootType,
+                                                    VkImageCompressionControlEXT* forUnmarshaling,
+                                                    uint8_t** ptr);
+
+void reservedunmarshal_VkSubresourceLayout2EXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkSubresourceLayout2EXT* forUnmarshaling,
+                                               uint8_t** ptr);
+
+void reservedunmarshal_VkImageSubresource2EXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkImageSubresource2EXT* forUnmarshaling,
+                                              uint8_t** ptr);
+
+void reservedunmarshal_VkImageCompressionPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageCompressionPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+void reservedunmarshal_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* forUnmarshaling, uint8_t** ptr);
 
 #endif
 #ifdef VK_EXT_4444_formats
@@ -3461,6 +3930,41 @@ void reservedunmarshal_VkPhysicalDevice4444FormatsFeaturesEXT(
     VkPhysicalDevice4444FormatsFeaturesEXT* forUnmarshaling, uint8_t** ptr);
 
 #endif
+#ifdef VK_EXT_device_fault
+void reservedunmarshal_VkPhysicalDeviceFaultFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFaultFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDeviceFaultCountsEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkDeviceFaultCountsEXT* forUnmarshaling,
+                                              uint8_t** ptr);
+
+void reservedunmarshal_VkDeviceFaultAddressInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkDeviceFaultAddressInfoEXT* forUnmarshaling,
+                                                   uint8_t** ptr);
+
+void reservedunmarshal_VkDeviceFaultVendorInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkDeviceFaultVendorInfoEXT* forUnmarshaling,
+                                                  uint8_t** ptr);
+
+void reservedunmarshal_VkDeviceFaultInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                            VkDeviceFaultInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceFaultVendorBinaryHeaderVersionOneEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+void reservedunmarshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+DEFINE_ALIAS_FUNCTION(
+    reservedunmarshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
+    reservedunmarshal_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM)
+
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 void reservedunmarshal_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -3476,17 +3980,26 @@ void reservedunmarshal_VkDirectFBSurfaceCreateInfoEXT(
 
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-void reservedunmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+void reservedunmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* forUnmarshaling, uint8_t** ptr);
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkMutableDescriptorTypeListVALVE(
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT,
+                      reservedunmarshal_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)
+
+void reservedunmarshal_VkMutableDescriptorTypeListEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkMutableDescriptorTypeListVALVE* forUnmarshaling, uint8_t** ptr);
+    VkMutableDescriptorTypeListEXT* forUnmarshaling, uint8_t** ptr);
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkMutableDescriptorTypeListEXT,
+                      reservedunmarshal_VkMutableDescriptorTypeListVALVE)
 
-void reservedunmarshal_VkMutableDescriptorTypeCreateInfoVALVE(
+void reservedunmarshal_VkMutableDescriptorTypeCreateInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkMutableDescriptorTypeCreateInfoVALVE* forUnmarshaling, uint8_t** ptr);
+    VkMutableDescriptorTypeCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkMutableDescriptorTypeCreateInfoEXT,
+                      reservedunmarshal_VkMutableDescriptorTypeCreateInfoVALVE)
 
 #endif
 #ifdef VK_EXT_vertex_input_dynamic_state
@@ -3509,6 +4022,26 @@ void reservedunmarshal_VkPhysicalDeviceDrmPropertiesEXT(
     VkPhysicalDeviceDrmPropertiesEXT* forUnmarshaling, uint8_t** ptr);
 
 #endif
+#ifdef VK_EXT_device_address_binding_report
+void reservedunmarshal_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDeviceAddressBindingCallbackDataEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDeviceAddressBindingCallbackDataEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_depth_clip_control
+void reservedunmarshal_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDepthClipControlFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineViewportDepthClipControlCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 void reservedunmarshal_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -3612,6 +4145,32 @@ void reservedunmarshal_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
     VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* forUnmarshaling, uint8_t** ptr);
 
 #endif
+#ifdef VK_EXT_pipeline_properties
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPipelineInfoKHR, reservedunmarshal_VkPipelineInfoEXT)
+
+void reservedunmarshal_VkPipelinePropertiesIdentifierEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelinePropertiesIdentifierEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+void reservedunmarshal_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkSubpassResolvePerformanceQueryEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSubpassResolvePerformanceQueryEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkMultisampledRenderToSingleSampledInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkMultisampledRenderToSingleSampledInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void reservedunmarshal_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -3635,6 +4194,12 @@ void reservedunmarshal_VkPipelineColorWriteCreateInfoEXT(
     VkPipelineColorWriteCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
 
 #endif
+#ifdef VK_EXT_primitives_generated_query
+void reservedunmarshal_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
 #ifdef VK_GOOGLE_gfxstream
 void reservedunmarshal_VkImportColorBufferGOOGLE(VulkanStream* vkStream, VkStructureType rootType,
                                                  VkImportColorBufferGOOGLE* forUnmarshaling,
@@ -3648,13 +4213,21 @@ void reservedunmarshal_VkCreateBlobGOOGLE(VulkanStream* vkStream, VkStructureTyp
 
 #endif
 #ifdef VK_EXT_global_priority_query
-void reservedunmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR,
+                      reservedunmarshal_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT)
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkQueueFamilyGlobalPriorityPropertiesKHR,
+                      reservedunmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT)
+
+#endif
+#ifdef VK_EXT_image_view_min_lod
+void reservedunmarshal_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT* forUnmarshaling, uint8_t** ptr);
 
-void reservedunmarshal_VkQueueFamilyGlobalPriorityPropertiesEXT(
+void reservedunmarshal_VkImageViewMinLodCreateInfoEXT(
     VulkanStream* vkStream, VkStructureType rootType,
-    VkQueueFamilyGlobalPriorityPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+    VkImageViewMinLodCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
 
 #endif
 #ifdef VK_EXT_multi_draw
@@ -3674,8 +4247,101 @@ void reservedunmarshal_VkMultiDrawIndexedInfoEXT(VulkanStream* vkStream, VkStruc
                                                  uint8_t** ptr);
 
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+void reservedunmarshal_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_shader_tile_image
+void reservedunmarshal_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderTileImageFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderTileImagePropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_opacity_micromap
+void reservedunmarshal_VkMicromapUsageEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                          VkMicromapUsageEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkDeviceOrHostAddressKHR* forUnmarshaling,
+                                                uint8_t** ptr);
+
+void reservedunmarshal_VkMicromapBuildInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                              VkMicromapBuildInfoEXT* forUnmarshaling,
+                                              uint8_t** ptr);
+
+void reservedunmarshal_VkMicromapCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkMicromapCreateInfoEXT* forUnmarshaling,
+                                               uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkMicromapVersionInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                VkMicromapVersionInfoEXT* forUnmarshaling,
+                                                uint8_t** ptr);
+
+void reservedunmarshal_VkCopyMicromapToMemoryInfoEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkCopyMicromapToMemoryInfoEXT* forUnmarshaling,
+                                                     uint8_t** ptr);
+
+void reservedunmarshal_VkCopyMemoryToMicromapInfoEXT(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkCopyMemoryToMicromapInfoEXT* forUnmarshaling,
+                                                     uint8_t** ptr);
+
+void reservedunmarshal_VkCopyMicromapInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkCopyMicromapInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkMicromapBuildSizesInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkMicromapBuildSizesInfoEXT* forUnmarshaling,
+                                                   uint8_t** ptr);
+
+void reservedunmarshal_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkAccelerationStructureTrianglesOpacityMicromapEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkMicromapTriangleEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkMicromapTriangleEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_NV_displacement_micromap
+void reservedunmarshal_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkAccelerationStructureTrianglesDisplacementMicromapNV* forUnmarshaling, uint8_t** ptr);
+
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void reservedunmarshal_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* forUnmarshaling, uint8_t** ptr);
+
+#endif
 #ifdef VK_EXT_border_color_swizzle
 void reservedunmarshal_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
     VulkanStream* vkStream, VkStructureType rootType,
@@ -3692,11 +4358,326 @@ void reservedunmarshal_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
     VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* forUnmarshaling, uint8_t** ptr);
 
 #endif
-#ifdef VK_KHR_acceleration_structure
-void reservedunmarshal_VkDeviceOrHostAddressKHR(VulkanStream* vkStream, VkStructureType rootType,
-                                                VkDeviceOrHostAddressKHR* forUnmarshaling,
-                                                uint8_t** ptr);
+#ifdef VK_ARM_shader_core_properties
+void reservedunmarshal_VkPhysicalDeviceShaderCorePropertiesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderCorePropertiesARM* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+void reservedunmarshal_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* forUnmarshaling, uint8_t** ptr);
 
+void reservedunmarshal_VkImageViewSlicedCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageViewSlicedCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void reservedunmarshal_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDescriptorSetBindingReferenceVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorSetBindingReferenceVALVE* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDescriptorSetLayoutHostMappingInfoVALVE* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+void reservedunmarshal_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+void reservedunmarshal_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+void reservedunmarshal_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void reservedunmarshal_VkCopyMemoryIndirectCommandNV(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkCopyMemoryIndirectCommandNV* forUnmarshaling,
+                                                     uint8_t** ptr);
+
+void reservedunmarshal_VkCopyMemoryToImageIndirectCommandNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkCopyMemoryToImageIndirectCommandNV* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_NV_memory_decompression
+void reservedunmarshal_VkDecompressMemoryRegionNV(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkDecompressMemoryRegionNV* forUnmarshaling,
+                                                  uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_NV_linear_color_attachment
+void reservedunmarshal_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+void reservedunmarshal_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_QCOM_image_processing
+void reservedunmarshal_VkImageViewSampleWeightCreateInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkImageViewSampleWeightCreateInfoQCOM* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageProcessingFeaturesQCOM* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceImageProcessingPropertiesQCOM* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void reservedunmarshal_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkColorBlendEquationEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkColorBlendEquationEXT* forUnmarshaling,
+                                               uint8_t** ptr);
+
+void reservedunmarshal_VkColorBlendAdvancedEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                               VkColorBlendAdvancedEXT* forUnmarshaling,
+                                               uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+void reservedunmarshal_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkRenderPassCreationControlEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassCreationControlEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkRenderPassCreationFeedbackInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassCreationFeedbackInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkRenderPassCreationFeedbackCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassCreationFeedbackCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkRenderPassSubpassFeedbackInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassSubpassFeedbackInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkRenderPassSubpassFeedbackCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+void reservedunmarshal_VkDirectDriverLoadingInfoLUNARG(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDirectDriverLoadingInfoLUNARG* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDirectDriverLoadingListLUNARG(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDirectDriverLoadingListLUNARG* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void reservedunmarshal_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkShaderModuleIdentifierEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                                   VkShaderModuleIdentifierEXT* forUnmarshaling,
+                                                   uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+void reservedunmarshal_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpticalFlowFeaturesNV* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceOpticalFlowPropertiesNV* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkOpticalFlowImageFormatInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpticalFlowImageFormatInfoNV* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkOpticalFlowImageFormatPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpticalFlowImageFormatPropertiesNV* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkOpticalFlowSessionCreateInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpticalFlowSessionCreateInfoNV* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkOpticalFlowSessionCreatePrivateDataInfoNV* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkOpticalFlowExecuteInfoNV(VulkanStream* vkStream, VkStructureType rootType,
+                                                  VkOpticalFlowExecuteInfoNV* forUnmarshaling,
+                                                  uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_legacy_dithering
+void reservedunmarshal_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+void reservedunmarshal_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_shader_object
+void reservedunmarshal_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderObjectFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderObjectPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkShaderCreateInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+                                             VkShaderCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+DEFINE_ALIAS_FUNCTION(reservedunmarshal_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      reservedunmarshal_VkShaderRequiredSubgroupSizeCreateInfoEXT)
+
+#endif
+#ifdef VK_QCOM_tile_properties
+void reservedunmarshal_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceTilePropertiesFeaturesQCOM* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkTilePropertiesQCOM(VulkanStream* vkStream, VkStructureType rootType,
+                                            VkTilePropertiesQCOM* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_SEC_amigo_profiling
+void reservedunmarshal_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAmigoProfilingFeaturesSEC* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkAmigoProfilingSubmitInfoSEC(VulkanStream* vkStream,
+                                                     VkStructureType rootType,
+                                                     VkAmigoProfilingSubmitInfoSEC* forUnmarshaling,
+                                                     uint8_t** ptr);
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+void reservedunmarshal_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+void reservedunmarshal_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+void reservedunmarshal_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+void reservedunmarshal_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+void reservedunmarshal_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+void reservedunmarshal_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
+#ifdef VK_KHR_acceleration_structure
 void reservedunmarshal_VkAccelerationStructureBuildRangeInfoKHR(
     VulkanStream* vkStream, VkStructureType rootType,
     VkAccelerationStructureBuildRangeInfoKHR* forUnmarshaling, uint8_t** ptr);
@@ -3803,6 +4784,20 @@ void reservedunmarshal_VkPhysicalDeviceRayQueryFeaturesKHR(
     VkPhysicalDeviceRayQueryFeaturesKHR* forUnmarshaling, uint8_t** ptr);
 
 #endif
+#ifdef VK_EXT_mesh_shader
+void reservedunmarshal_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMeshShaderFeaturesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkPhysicalDeviceMeshShaderPropertiesEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDrawMeshTasksIndirectCommandEXT(
+    VulkanStream* vkStream, VkStructureType rootType,
+    VkDrawMeshTasksIndirectCommandEXT* forUnmarshaling, uint8_t** ptr);
+
+#endif
 
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_testing.cpp b/stream-servers/vulkan/cereal/common/goldfish_vk_testing.cpp
index 19450c0b..08f5ef2e 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_testing.cpp
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_testing.cpp
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_testing
 //
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (impl) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -6268,6 +6268,1642 @@ void checkEqual_VkDeviceMemoryOpaqueCaptureAddressInfo(
 }
 
 #endif
+#ifdef VK_VERSION_1_3
+void checkEqual_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features* a,
+                                                 const VkPhysicalDeviceVulkan13Features* b,
+                                                 OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->robustImageAccess) == (b->robustImageAccess))) {
+        onFail("a->robustImageAccess (Error: Value not equal)");
+    };
+    if (!((a->inlineUniformBlock) == (b->inlineUniformBlock))) {
+        onFail("a->inlineUniformBlock (Error: Value not equal)");
+    };
+    if (!((a->descriptorBindingInlineUniformBlockUpdateAfterBind) ==
+          (b->descriptorBindingInlineUniformBlockUpdateAfterBind))) {
+        onFail("a->descriptorBindingInlineUniformBlockUpdateAfterBind (Error: Value not equal)");
+    };
+    if (!((a->pipelineCreationCacheControl) == (b->pipelineCreationCacheControl))) {
+        onFail("a->pipelineCreationCacheControl (Error: Value not equal)");
+    };
+    if (!((a->privateData) == (b->privateData))) {
+        onFail("a->privateData (Error: Value not equal)");
+    };
+    if (!((a->shaderDemoteToHelperInvocation) == (b->shaderDemoteToHelperInvocation))) {
+        onFail("a->shaderDemoteToHelperInvocation (Error: Value not equal)");
+    };
+    if (!((a->shaderTerminateInvocation) == (b->shaderTerminateInvocation))) {
+        onFail("a->shaderTerminateInvocation (Error: Value not equal)");
+    };
+    if (!((a->subgroupSizeControl) == (b->subgroupSizeControl))) {
+        onFail("a->subgroupSizeControl (Error: Value not equal)");
+    };
+    if (!((a->computeFullSubgroups) == (b->computeFullSubgroups))) {
+        onFail("a->computeFullSubgroups (Error: Value not equal)");
+    };
+    if (!((a->synchronization2) == (b->synchronization2))) {
+        onFail("a->synchronization2 (Error: Value not equal)");
+    };
+    if (!((a->textureCompressionASTC_HDR) == (b->textureCompressionASTC_HDR))) {
+        onFail("a->textureCompressionASTC_HDR (Error: Value not equal)");
+    };
+    if (!((a->shaderZeroInitializeWorkgroupMemory) == (b->shaderZeroInitializeWorkgroupMemory))) {
+        onFail("a->shaderZeroInitializeWorkgroupMemory (Error: Value not equal)");
+    };
+    if (!((a->dynamicRendering) == (b->dynamicRendering))) {
+        onFail("a->dynamicRendering (Error: Value not equal)");
+    };
+    if (!((a->shaderIntegerDotProduct) == (b->shaderIntegerDotProduct))) {
+        onFail("a->shaderIntegerDotProduct (Error: Value not equal)");
+    };
+    if (!((a->maintenance4) == (b->maintenance4))) {
+        onFail("a->maintenance4 (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties* a,
+                                                   const VkPhysicalDeviceVulkan13Properties* b,
+                                                   OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->minSubgroupSize) == (b->minSubgroupSize))) {
+        onFail("a->minSubgroupSize (Error: Value not equal)");
+    };
+    if (!((a->maxSubgroupSize) == (b->maxSubgroupSize))) {
+        onFail("a->maxSubgroupSize (Error: Value not equal)");
+    };
+    if (!((a->maxComputeWorkgroupSubgroups) == (b->maxComputeWorkgroupSubgroups))) {
+        onFail("a->maxComputeWorkgroupSubgroups (Error: Value not equal)");
+    };
+    if (!((a->requiredSubgroupSizeStages) == (b->requiredSubgroupSizeStages))) {
+        onFail("a->requiredSubgroupSizeStages (Error: Value not equal)");
+    };
+    if (!((a->maxInlineUniformBlockSize) == (b->maxInlineUniformBlockSize))) {
+        onFail("a->maxInlineUniformBlockSize (Error: Value not equal)");
+    };
+    if (!((a->maxPerStageDescriptorInlineUniformBlocks) ==
+          (b->maxPerStageDescriptorInlineUniformBlocks))) {
+        onFail("a->maxPerStageDescriptorInlineUniformBlocks (Error: Value not equal)");
+    };
+    if (!((a->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks) ==
+          (b->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks))) {
+        onFail(
+            "a->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks (Error: Value not equal)");
+    };
+    if (!((a->maxDescriptorSetInlineUniformBlocks) == (b->maxDescriptorSetInlineUniformBlocks))) {
+        onFail("a->maxDescriptorSetInlineUniformBlocks (Error: Value not equal)");
+    };
+    if (!((a->maxDescriptorSetUpdateAfterBindInlineUniformBlocks) ==
+          (b->maxDescriptorSetUpdateAfterBindInlineUniformBlocks))) {
+        onFail("a->maxDescriptorSetUpdateAfterBindInlineUniformBlocks (Error: Value not equal)");
+    };
+    if (!((a->maxInlineUniformTotalSize) == (b->maxInlineUniformTotalSize))) {
+        onFail("a->maxInlineUniformTotalSize (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct8BitUnsignedAccelerated) ==
+          (b->integerDotProduct8BitUnsignedAccelerated))) {
+        onFail("a->integerDotProduct8BitUnsignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct8BitSignedAccelerated) ==
+          (b->integerDotProduct8BitSignedAccelerated))) {
+        onFail("a->integerDotProduct8BitSignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct8BitMixedSignednessAccelerated) ==
+          (b->integerDotProduct8BitMixedSignednessAccelerated))) {
+        onFail("a->integerDotProduct8BitMixedSignednessAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct4x8BitPackedUnsignedAccelerated) ==
+          (b->integerDotProduct4x8BitPackedUnsignedAccelerated))) {
+        onFail("a->integerDotProduct4x8BitPackedUnsignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct4x8BitPackedSignedAccelerated) ==
+          (b->integerDotProduct4x8BitPackedSignedAccelerated))) {
+        onFail("a->integerDotProduct4x8BitPackedSignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct4x8BitPackedMixedSignednessAccelerated) ==
+          (b->integerDotProduct4x8BitPackedMixedSignednessAccelerated))) {
+        onFail(
+            "a->integerDotProduct4x8BitPackedMixedSignednessAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct16BitUnsignedAccelerated) ==
+          (b->integerDotProduct16BitUnsignedAccelerated))) {
+        onFail("a->integerDotProduct16BitUnsignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct16BitSignedAccelerated) ==
+          (b->integerDotProduct16BitSignedAccelerated))) {
+        onFail("a->integerDotProduct16BitSignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct16BitMixedSignednessAccelerated) ==
+          (b->integerDotProduct16BitMixedSignednessAccelerated))) {
+        onFail("a->integerDotProduct16BitMixedSignednessAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct32BitUnsignedAccelerated) ==
+          (b->integerDotProduct32BitUnsignedAccelerated))) {
+        onFail("a->integerDotProduct32BitUnsignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct32BitSignedAccelerated) ==
+          (b->integerDotProduct32BitSignedAccelerated))) {
+        onFail("a->integerDotProduct32BitSignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct32BitMixedSignednessAccelerated) ==
+          (b->integerDotProduct32BitMixedSignednessAccelerated))) {
+        onFail("a->integerDotProduct32BitMixedSignednessAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct64BitUnsignedAccelerated) ==
+          (b->integerDotProduct64BitUnsignedAccelerated))) {
+        onFail("a->integerDotProduct64BitUnsignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct64BitSignedAccelerated) ==
+          (b->integerDotProduct64BitSignedAccelerated))) {
+        onFail("a->integerDotProduct64BitSignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct64BitMixedSignednessAccelerated) ==
+          (b->integerDotProduct64BitMixedSignednessAccelerated))) {
+        onFail("a->integerDotProduct64BitMixedSignednessAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating8BitSignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating8BitSignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating8BitSignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated (Error: "
+            "Value not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated (Error: "
+            "Value not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated (Error: Value "
+            "not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated "
+            "(Error: Value not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating16BitSignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating16BitSignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating16BitSignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated (Error: "
+            "Value not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating32BitSignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating32BitSignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating32BitSignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated (Error: "
+            "Value not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating64BitSignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating64BitSignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating64BitSignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated (Error: "
+            "Value not equal)");
+    };
+    if (!((a->storageTexelBufferOffsetAlignmentBytes) ==
+          (b->storageTexelBufferOffsetAlignmentBytes))) {
+        onFail("a->storageTexelBufferOffsetAlignmentBytes (Error: Value not equal)");
+    };
+    if (!((a->storageTexelBufferOffsetSingleTexelAlignment) ==
+          (b->storageTexelBufferOffsetSingleTexelAlignment))) {
+        onFail("a->storageTexelBufferOffsetSingleTexelAlignment (Error: Value not equal)");
+    };
+    if (!((a->uniformTexelBufferOffsetAlignmentBytes) ==
+          (b->uniformTexelBufferOffsetAlignmentBytes))) {
+        onFail("a->uniformTexelBufferOffsetAlignmentBytes (Error: Value not equal)");
+    };
+    if (!((a->uniformTexelBufferOffsetSingleTexelAlignment) ==
+          (b->uniformTexelBufferOffsetSingleTexelAlignment))) {
+        onFail("a->uniformTexelBufferOffsetSingleTexelAlignment (Error: Value not equal)");
+    };
+    if (!((a->maxBufferSize) == (b->maxBufferSize))) {
+        onFail("a->maxBufferSize (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPipelineCreationFeedback(const VkPipelineCreationFeedback* a,
+                                           const VkPipelineCreationFeedback* b,
+                                           OnFailCompareFunc onFail) {
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+    if (!((a->duration) == (b->duration))) {
+        onFail("a->duration (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo* a,
+                                                     const VkPipelineCreationFeedbackCreateInfo* b,
+                                                     OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if ((a->pPipelineCreationFeedback) && (b->pPipelineCreationFeedback)) {
+        checkEqual_VkPipelineCreationFeedback(a->pPipelineCreationFeedback,
+                                              b->pPipelineCreationFeedback, onFail);
+    }
+    if (!((a->pipelineStageCreationFeedbackCount) == (b->pipelineStageCreationFeedbackCount))) {
+        onFail("a->pipelineStageCreationFeedbackCount (Error: Value not equal)");
+    };
+    if ((a->pPipelineStageCreationFeedbacks) && (b->pPipelineStageCreationFeedbacks)) {
+        if (!((a->pipelineStageCreationFeedbackCount) == (b->pipelineStageCreationFeedbackCount))) {
+            onFail("a->pPipelineStageCreationFeedbacks (Error: Lengths not equal)");
+        };
+        if ((a->pipelineStageCreationFeedbackCount) == (b->pipelineStageCreationFeedbackCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->pipelineStageCreationFeedbackCount; ++i) {
+                    checkEqual_VkPipelineCreationFeedback(a->pPipelineStageCreationFeedbacks + i,
+                                                          b->pPipelineStageCreationFeedbacks + i,
+                                                          onFail);
+                }
+            }
+        }
+    }
+}
+
+void checkEqual_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    const VkPhysicalDeviceShaderTerminateInvocationFeatures* a,
+    const VkPhysicalDeviceShaderTerminateInvocationFeatures* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->shaderTerminateInvocation) == (b->shaderTerminateInvocation))) {
+        onFail("a->shaderTerminateInvocation (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties* a,
+                                               const VkPhysicalDeviceToolProperties* b,
+                                               OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((memcmp(a->name, b->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char)) == 0))) {
+        onFail("a->name (Error: Unequal static array)");
+    };
+    if (!((memcmp(a->version, b->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char)) == 0))) {
+        onFail("a->version (Error: Unequal static array)");
+    };
+    if (!((a->purposes) == (b->purposes))) {
+        onFail("a->purposes (Error: Value not equal)");
+    };
+    if (!((memcmp(a->description, b->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)) == 0))) {
+        onFail("a->description (Error: Unequal static array)");
+    };
+    if (!((memcmp(a->layer, b->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char)) == 0))) {
+        onFail("a->layer (Error: Unequal static array)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* a,
+    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->shaderDemoteToHelperInvocation) == (b->shaderDemoteToHelperInvocation))) {
+        onFail("a->shaderDemoteToHelperInvocation (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDevicePrivateDataFeatures(const VkPhysicalDevicePrivateDataFeatures* a,
+                                                    const VkPhysicalDevicePrivateDataFeatures* b,
+                                                    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->privateData) == (b->privateData))) {
+        onFail("a->privateData (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo* a,
+                                              const VkDevicePrivateDataCreateInfo* b,
+                                              OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->privateDataSlotRequestCount) == (b->privateDataSlotRequestCount))) {
+        onFail("a->privateDataSlotRequestCount (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPrivateDataSlotCreateInfo(const VkPrivateDataSlotCreateInfo* a,
+                                            const VkPrivateDataSlotCreateInfo* b,
+                                            OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    const VkPhysicalDevicePipelineCreationCacheControlFeatures* a,
+    const VkPhysicalDevicePipelineCreationCacheControlFeatures* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->pipelineCreationCacheControl) == (b->pipelineCreationCacheControl))) {
+        onFail("a->pipelineCreationCacheControl (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkMemoryBarrier2(const VkMemoryBarrier2* a, const VkMemoryBarrier2* b,
+                                 OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->srcStageMask) == (b->srcStageMask))) {
+        onFail("a->srcStageMask (Error: Value not equal)");
+    };
+    if (!((a->srcAccessMask) == (b->srcAccessMask))) {
+        onFail("a->srcAccessMask (Error: Value not equal)");
+    };
+    if (!((a->dstStageMask) == (b->dstStageMask))) {
+        onFail("a->dstStageMask (Error: Value not equal)");
+    };
+    if (!((a->dstAccessMask) == (b->dstAccessMask))) {
+        onFail("a->dstAccessMask (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkBufferMemoryBarrier2(const VkBufferMemoryBarrier2* a,
+                                       const VkBufferMemoryBarrier2* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->srcStageMask) == (b->srcStageMask))) {
+        onFail("a->srcStageMask (Error: Value not equal)");
+    };
+    if (!((a->srcAccessMask) == (b->srcAccessMask))) {
+        onFail("a->srcAccessMask (Error: Value not equal)");
+    };
+    if (!((a->dstStageMask) == (b->dstStageMask))) {
+        onFail("a->dstStageMask (Error: Value not equal)");
+    };
+    if (!((a->dstAccessMask) == (b->dstAccessMask))) {
+        onFail("a->dstAccessMask (Error: Value not equal)");
+    };
+    if (!((a->srcQueueFamilyIndex) == (b->srcQueueFamilyIndex))) {
+        onFail("a->srcQueueFamilyIndex (Error: Value not equal)");
+    };
+    if (!((a->dstQueueFamilyIndex) == (b->dstQueueFamilyIndex))) {
+        onFail("a->dstQueueFamilyIndex (Error: Value not equal)");
+    };
+    if (!((a->buffer) == (b->buffer))) {
+        onFail("a->buffer (Error: Value not equal)");
+    };
+    if (!((a->offset) == (b->offset))) {
+        onFail("a->offset (Error: Value not equal)");
+    };
+    if (!((a->size) == (b->size))) {
+        onFail("a->size (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkImageMemoryBarrier2(const VkImageMemoryBarrier2* a,
+                                      const VkImageMemoryBarrier2* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->srcStageMask) == (b->srcStageMask))) {
+        onFail("a->srcStageMask (Error: Value not equal)");
+    };
+    if (!((a->srcAccessMask) == (b->srcAccessMask))) {
+        onFail("a->srcAccessMask (Error: Value not equal)");
+    };
+    if (!((a->dstStageMask) == (b->dstStageMask))) {
+        onFail("a->dstStageMask (Error: Value not equal)");
+    };
+    if (!((a->dstAccessMask) == (b->dstAccessMask))) {
+        onFail("a->dstAccessMask (Error: Value not equal)");
+    };
+    if (!((a->oldLayout) == (b->oldLayout))) {
+        onFail("a->oldLayout (Error: Value not equal)");
+    };
+    if (!((a->newLayout) == (b->newLayout))) {
+        onFail("a->newLayout (Error: Value not equal)");
+    };
+    if (!((a->srcQueueFamilyIndex) == (b->srcQueueFamilyIndex))) {
+        onFail("a->srcQueueFamilyIndex (Error: Value not equal)");
+    };
+    if (!((a->dstQueueFamilyIndex) == (b->dstQueueFamilyIndex))) {
+        onFail("a->dstQueueFamilyIndex (Error: Value not equal)");
+    };
+    if (!((a->image) == (b->image))) {
+        onFail("a->image (Error: Value not equal)");
+    };
+    checkEqual_VkImageSubresourceRange(&a->subresourceRange, &b->subresourceRange, onFail);
+}
+
+void checkEqual_VkDependencyInfo(const VkDependencyInfo* a, const VkDependencyInfo* b,
+                                 OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->dependencyFlags) == (b->dependencyFlags))) {
+        onFail("a->dependencyFlags (Error: Value not equal)");
+    };
+    if (!((a->memoryBarrierCount) == (b->memoryBarrierCount))) {
+        onFail("a->memoryBarrierCount (Error: Value not equal)");
+    };
+    if ((a->pMemoryBarriers) && (b->pMemoryBarriers)) {
+        if (!((a->memoryBarrierCount) == (b->memoryBarrierCount))) {
+            onFail("a->pMemoryBarriers (Error: Lengths not equal)");
+        };
+        if ((a->memoryBarrierCount) == (b->memoryBarrierCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->memoryBarrierCount; ++i) {
+                    checkEqual_VkMemoryBarrier2(a->pMemoryBarriers + i, b->pMemoryBarriers + i,
+                                                onFail);
+                }
+            }
+        }
+    }
+    if (!((a->bufferMemoryBarrierCount) == (b->bufferMemoryBarrierCount))) {
+        onFail("a->bufferMemoryBarrierCount (Error: Value not equal)");
+    };
+    if ((a->pBufferMemoryBarriers) && (b->pBufferMemoryBarriers)) {
+        if (!((a->bufferMemoryBarrierCount) == (b->bufferMemoryBarrierCount))) {
+            onFail("a->pBufferMemoryBarriers (Error: Lengths not equal)");
+        };
+        if ((a->bufferMemoryBarrierCount) == (b->bufferMemoryBarrierCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->bufferMemoryBarrierCount; ++i) {
+                    checkEqual_VkBufferMemoryBarrier2(a->pBufferMemoryBarriers + i,
+                                                      b->pBufferMemoryBarriers + i, onFail);
+                }
+            }
+        }
+    }
+    if (!((a->imageMemoryBarrierCount) == (b->imageMemoryBarrierCount))) {
+        onFail("a->imageMemoryBarrierCount (Error: Value not equal)");
+    };
+    if ((a->pImageMemoryBarriers) && (b->pImageMemoryBarriers)) {
+        if (!((a->imageMemoryBarrierCount) == (b->imageMemoryBarrierCount))) {
+            onFail("a->pImageMemoryBarriers (Error: Lengths not equal)");
+        };
+        if ((a->imageMemoryBarrierCount) == (b->imageMemoryBarrierCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->imageMemoryBarrierCount; ++i) {
+                    checkEqual_VkImageMemoryBarrier2(a->pImageMemoryBarriers + i,
+                                                     b->pImageMemoryBarriers + i, onFail);
+                }
+            }
+        }
+    }
+}
+
+void checkEqual_VkSemaphoreSubmitInfo(const VkSemaphoreSubmitInfo* a,
+                                      const VkSemaphoreSubmitInfo* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->semaphore) == (b->semaphore))) {
+        onFail("a->semaphore (Error: Value not equal)");
+    };
+    if (!((a->value) == (b->value))) {
+        onFail("a->value (Error: Value not equal)");
+    };
+    if (!((a->stageMask) == (b->stageMask))) {
+        onFail("a->stageMask (Error: Value not equal)");
+    };
+    if (!((a->deviceIndex) == (b->deviceIndex))) {
+        onFail("a->deviceIndex (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkCommandBufferSubmitInfo(const VkCommandBufferSubmitInfo* a,
+                                          const VkCommandBufferSubmitInfo* b,
+                                          OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->commandBuffer) == (b->commandBuffer))) {
+        onFail("a->commandBuffer (Error: Value not equal)");
+    };
+    if (!((a->deviceMask) == (b->deviceMask))) {
+        onFail("a->deviceMask (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkSubmitInfo2(const VkSubmitInfo2* a, const VkSubmitInfo2* b,
+                              OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+    if (!((a->waitSemaphoreInfoCount) == (b->waitSemaphoreInfoCount))) {
+        onFail("a->waitSemaphoreInfoCount (Error: Value not equal)");
+    };
+    if ((a->pWaitSemaphoreInfos) && (b->pWaitSemaphoreInfos)) {
+        if (!((a->waitSemaphoreInfoCount) == (b->waitSemaphoreInfoCount))) {
+            onFail("a->pWaitSemaphoreInfos (Error: Lengths not equal)");
+        };
+        if ((a->waitSemaphoreInfoCount) == (b->waitSemaphoreInfoCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->waitSemaphoreInfoCount; ++i) {
+                    checkEqual_VkSemaphoreSubmitInfo(a->pWaitSemaphoreInfos + i,
+                                                     b->pWaitSemaphoreInfos + i, onFail);
+                }
+            }
+        }
+    }
+    if (!((a->commandBufferInfoCount) == (b->commandBufferInfoCount))) {
+        onFail("a->commandBufferInfoCount (Error: Value not equal)");
+    };
+    if ((a->pCommandBufferInfos) && (b->pCommandBufferInfos)) {
+        if (!((a->commandBufferInfoCount) == (b->commandBufferInfoCount))) {
+            onFail("a->pCommandBufferInfos (Error: Lengths not equal)");
+        };
+        if ((a->commandBufferInfoCount) == (b->commandBufferInfoCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->commandBufferInfoCount; ++i) {
+                    checkEqual_VkCommandBufferSubmitInfo(a->pCommandBufferInfos + i,
+                                                         b->pCommandBufferInfos + i, onFail);
+                }
+            }
+        }
+    }
+    if (!((a->signalSemaphoreInfoCount) == (b->signalSemaphoreInfoCount))) {
+        onFail("a->signalSemaphoreInfoCount (Error: Value not equal)");
+    };
+    if ((a->pSignalSemaphoreInfos) && (b->pSignalSemaphoreInfos)) {
+        if (!((a->signalSemaphoreInfoCount) == (b->signalSemaphoreInfoCount))) {
+            onFail("a->pSignalSemaphoreInfos (Error: Lengths not equal)");
+        };
+        if ((a->signalSemaphoreInfoCount) == (b->signalSemaphoreInfoCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->signalSemaphoreInfoCount; ++i) {
+                    checkEqual_VkSemaphoreSubmitInfo(a->pSignalSemaphoreInfos + i,
+                                                     b->pSignalSemaphoreInfos + i, onFail);
+                }
+            }
+        }
+    }
+}
+
+void checkEqual_VkPhysicalDeviceSynchronization2Features(
+    const VkPhysicalDeviceSynchronization2Features* a,
+    const VkPhysicalDeviceSynchronization2Features* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->synchronization2) == (b->synchronization2))) {
+        onFail("a->synchronization2 (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* a,
+    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->shaderZeroInitializeWorkgroupMemory) == (b->shaderZeroInitializeWorkgroupMemory))) {
+        onFail("a->shaderZeroInitializeWorkgroupMemory (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceImageRobustnessFeatures(
+    const VkPhysicalDeviceImageRobustnessFeatures* a,
+    const VkPhysicalDeviceImageRobustnessFeatures* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->robustImageAccess) == (b->robustImageAccess))) {
+        onFail("a->robustImageAccess (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkBufferCopy2(const VkBufferCopy2* a, const VkBufferCopy2* b,
+                              OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->srcOffset) == (b->srcOffset))) {
+        onFail("a->srcOffset (Error: Value not equal)");
+    };
+    if (!((a->dstOffset) == (b->dstOffset))) {
+        onFail("a->dstOffset (Error: Value not equal)");
+    };
+    if (!((a->size) == (b->size))) {
+        onFail("a->size (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkCopyBufferInfo2(const VkCopyBufferInfo2* a, const VkCopyBufferInfo2* b,
+                                  OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->srcBuffer) == (b->srcBuffer))) {
+        onFail("a->srcBuffer (Error: Value not equal)");
+    };
+    if (!((a->dstBuffer) == (b->dstBuffer))) {
+        onFail("a->dstBuffer (Error: Value not equal)");
+    };
+    if (!((a->regionCount) == (b->regionCount))) {
+        onFail("a->regionCount (Error: Value not equal)");
+    };
+    if ((a->pRegions) && (b->pRegions)) {
+        if (!((a->regionCount) == (b->regionCount))) {
+            onFail("a->pRegions (Error: Lengths not equal)");
+        };
+        if ((a->regionCount) == (b->regionCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->regionCount; ++i) {
+                    checkEqual_VkBufferCopy2(a->pRegions + i, b->pRegions + i, onFail);
+                }
+            }
+        }
+    }
+}
+
+void checkEqual_VkImageCopy2(const VkImageCopy2* a, const VkImageCopy2* b,
+                             OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    checkEqual_VkImageSubresourceLayers(&a->srcSubresource, &b->srcSubresource, onFail);
+    checkEqual_VkOffset3D(&a->srcOffset, &b->srcOffset, onFail);
+    checkEqual_VkImageSubresourceLayers(&a->dstSubresource, &b->dstSubresource, onFail);
+    checkEqual_VkOffset3D(&a->dstOffset, &b->dstOffset, onFail);
+    checkEqual_VkExtent3D(&a->extent, &b->extent, onFail);
+}
+
+void checkEqual_VkCopyImageInfo2(const VkCopyImageInfo2* a, const VkCopyImageInfo2* b,
+                                 OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->srcImage) == (b->srcImage))) {
+        onFail("a->srcImage (Error: Value not equal)");
+    };
+    if (!((a->srcImageLayout) == (b->srcImageLayout))) {
+        onFail("a->srcImageLayout (Error: Value not equal)");
+    };
+    if (!((a->dstImage) == (b->dstImage))) {
+        onFail("a->dstImage (Error: Value not equal)");
+    };
+    if (!((a->dstImageLayout) == (b->dstImageLayout))) {
+        onFail("a->dstImageLayout (Error: Value not equal)");
+    };
+    if (!((a->regionCount) == (b->regionCount))) {
+        onFail("a->regionCount (Error: Value not equal)");
+    };
+    if ((a->pRegions) && (b->pRegions)) {
+        if (!((a->regionCount) == (b->regionCount))) {
+            onFail("a->pRegions (Error: Lengths not equal)");
+        };
+        if ((a->regionCount) == (b->regionCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->regionCount; ++i) {
+                    checkEqual_VkImageCopy2(a->pRegions + i, b->pRegions + i, onFail);
+                }
+            }
+        }
+    }
+}
+
+void checkEqual_VkBufferImageCopy2(const VkBufferImageCopy2* a, const VkBufferImageCopy2* b,
+                                   OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->bufferOffset) == (b->bufferOffset))) {
+        onFail("a->bufferOffset (Error: Value not equal)");
+    };
+    if (!((a->bufferRowLength) == (b->bufferRowLength))) {
+        onFail("a->bufferRowLength (Error: Value not equal)");
+    };
+    if (!((a->bufferImageHeight) == (b->bufferImageHeight))) {
+        onFail("a->bufferImageHeight (Error: Value not equal)");
+    };
+    checkEqual_VkImageSubresourceLayers(&a->imageSubresource, &b->imageSubresource, onFail);
+    checkEqual_VkOffset3D(&a->imageOffset, &b->imageOffset, onFail);
+    checkEqual_VkExtent3D(&a->imageExtent, &b->imageExtent, onFail);
+}
+
+void checkEqual_VkCopyBufferToImageInfo2(const VkCopyBufferToImageInfo2* a,
+                                         const VkCopyBufferToImageInfo2* b,
+                                         OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->srcBuffer) == (b->srcBuffer))) {
+        onFail("a->srcBuffer (Error: Value not equal)");
+    };
+    if (!((a->dstImage) == (b->dstImage))) {
+        onFail("a->dstImage (Error: Value not equal)");
+    };
+    if (!((a->dstImageLayout) == (b->dstImageLayout))) {
+        onFail("a->dstImageLayout (Error: Value not equal)");
+    };
+    if (!((a->regionCount) == (b->regionCount))) {
+        onFail("a->regionCount (Error: Value not equal)");
+    };
+    if ((a->pRegions) && (b->pRegions)) {
+        if (!((a->regionCount) == (b->regionCount))) {
+            onFail("a->pRegions (Error: Lengths not equal)");
+        };
+        if ((a->regionCount) == (b->regionCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->regionCount; ++i) {
+                    checkEqual_VkBufferImageCopy2(a->pRegions + i, b->pRegions + i, onFail);
+                }
+            }
+        }
+    }
+}
+
+void checkEqual_VkCopyImageToBufferInfo2(const VkCopyImageToBufferInfo2* a,
+                                         const VkCopyImageToBufferInfo2* b,
+                                         OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->srcImage) == (b->srcImage))) {
+        onFail("a->srcImage (Error: Value not equal)");
+    };
+    if (!((a->srcImageLayout) == (b->srcImageLayout))) {
+        onFail("a->srcImageLayout (Error: Value not equal)");
+    };
+    if (!((a->dstBuffer) == (b->dstBuffer))) {
+        onFail("a->dstBuffer (Error: Value not equal)");
+    };
+    if (!((a->regionCount) == (b->regionCount))) {
+        onFail("a->regionCount (Error: Value not equal)");
+    };
+    if ((a->pRegions) && (b->pRegions)) {
+        if (!((a->regionCount) == (b->regionCount))) {
+            onFail("a->pRegions (Error: Lengths not equal)");
+        };
+        if ((a->regionCount) == (b->regionCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->regionCount; ++i) {
+                    checkEqual_VkBufferImageCopy2(a->pRegions + i, b->pRegions + i, onFail);
+                }
+            }
+        }
+    }
+}
+
+void checkEqual_VkImageBlit2(const VkImageBlit2* a, const VkImageBlit2* b,
+                             OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    checkEqual_VkImageSubresourceLayers(&a->srcSubresource, &b->srcSubresource, onFail);
+    if (!((2) == (2))) {
+        onFail("a->srcOffsets (Error: Lengths not equal)");
+    };
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        checkEqual_VkOffset3D(a->srcOffsets + i, b->srcOffsets + i, onFail);
+    }
+    checkEqual_VkImageSubresourceLayers(&a->dstSubresource, &b->dstSubresource, onFail);
+    if (!((2) == (2))) {
+        onFail("a->dstOffsets (Error: Lengths not equal)");
+    };
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        checkEqual_VkOffset3D(a->dstOffsets + i, b->dstOffsets + i, onFail);
+    }
+}
+
+void checkEqual_VkBlitImageInfo2(const VkBlitImageInfo2* a, const VkBlitImageInfo2* b,
+                                 OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->srcImage) == (b->srcImage))) {
+        onFail("a->srcImage (Error: Value not equal)");
+    };
+    if (!((a->srcImageLayout) == (b->srcImageLayout))) {
+        onFail("a->srcImageLayout (Error: Value not equal)");
+    };
+    if (!((a->dstImage) == (b->dstImage))) {
+        onFail("a->dstImage (Error: Value not equal)");
+    };
+    if (!((a->dstImageLayout) == (b->dstImageLayout))) {
+        onFail("a->dstImageLayout (Error: Value not equal)");
+    };
+    if (!((a->regionCount) == (b->regionCount))) {
+        onFail("a->regionCount (Error: Value not equal)");
+    };
+    if ((a->pRegions) && (b->pRegions)) {
+        if (!((a->regionCount) == (b->regionCount))) {
+            onFail("a->pRegions (Error: Lengths not equal)");
+        };
+        if ((a->regionCount) == (b->regionCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->regionCount; ++i) {
+                    checkEqual_VkImageBlit2(a->pRegions + i, b->pRegions + i, onFail);
+                }
+            }
+        }
+    }
+    if (!((a->filter) == (b->filter))) {
+        onFail("a->filter (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkImageResolve2(const VkImageResolve2* a, const VkImageResolve2* b,
+                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    checkEqual_VkImageSubresourceLayers(&a->srcSubresource, &b->srcSubresource, onFail);
+    checkEqual_VkOffset3D(&a->srcOffset, &b->srcOffset, onFail);
+    checkEqual_VkImageSubresourceLayers(&a->dstSubresource, &b->dstSubresource, onFail);
+    checkEqual_VkOffset3D(&a->dstOffset, &b->dstOffset, onFail);
+    checkEqual_VkExtent3D(&a->extent, &b->extent, onFail);
+}
+
+void checkEqual_VkResolveImageInfo2(const VkResolveImageInfo2* a, const VkResolveImageInfo2* b,
+                                    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->srcImage) == (b->srcImage))) {
+        onFail("a->srcImage (Error: Value not equal)");
+    };
+    if (!((a->srcImageLayout) == (b->srcImageLayout))) {
+        onFail("a->srcImageLayout (Error: Value not equal)");
+    };
+    if (!((a->dstImage) == (b->dstImage))) {
+        onFail("a->dstImage (Error: Value not equal)");
+    };
+    if (!((a->dstImageLayout) == (b->dstImageLayout))) {
+        onFail("a->dstImageLayout (Error: Value not equal)");
+    };
+    if (!((a->regionCount) == (b->regionCount))) {
+        onFail("a->regionCount (Error: Value not equal)");
+    };
+    if ((a->pRegions) && (b->pRegions)) {
+        if (!((a->regionCount) == (b->regionCount))) {
+            onFail("a->pRegions (Error: Lengths not equal)");
+        };
+        if ((a->regionCount) == (b->regionCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->regionCount; ++i) {
+                    checkEqual_VkImageResolve2(a->pRegions + i, b->pRegions + i, onFail);
+                }
+            }
+        }
+    }
+}
+
+void checkEqual_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    const VkPhysicalDeviceSubgroupSizeControlFeatures* a,
+    const VkPhysicalDeviceSubgroupSizeControlFeatures* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->subgroupSizeControl) == (b->subgroupSizeControl))) {
+        onFail("a->subgroupSizeControl (Error: Value not equal)");
+    };
+    if (!((a->computeFullSubgroups) == (b->computeFullSubgroups))) {
+        onFail("a->computeFullSubgroups (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceSubgroupSizeControlProperties(
+    const VkPhysicalDeviceSubgroupSizeControlProperties* a,
+    const VkPhysicalDeviceSubgroupSizeControlProperties* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->minSubgroupSize) == (b->minSubgroupSize))) {
+        onFail("a->minSubgroupSize (Error: Value not equal)");
+    };
+    if (!((a->maxSubgroupSize) == (b->maxSubgroupSize))) {
+        onFail("a->maxSubgroupSize (Error: Value not equal)");
+    };
+    if (!((a->maxComputeWorkgroupSubgroups) == (b->maxComputeWorkgroupSubgroups))) {
+        onFail("a->maxComputeWorkgroupSubgroups (Error: Value not equal)");
+    };
+    if (!((a->requiredSubgroupSizeStages) == (b->requiredSubgroupSizeStages))) {
+        onFail("a->requiredSubgroupSizeStages (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* a,
+    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->requiredSubgroupSize) == (b->requiredSubgroupSize))) {
+        onFail("a->requiredSubgroupSize (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceInlineUniformBlockFeatures(
+    const VkPhysicalDeviceInlineUniformBlockFeatures* a,
+    const VkPhysicalDeviceInlineUniformBlockFeatures* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->inlineUniformBlock) == (b->inlineUniformBlock))) {
+        onFail("a->inlineUniformBlock (Error: Value not equal)");
+    };
+    if (!((a->descriptorBindingInlineUniformBlockUpdateAfterBind) ==
+          (b->descriptorBindingInlineUniformBlockUpdateAfterBind))) {
+        onFail("a->descriptorBindingInlineUniformBlockUpdateAfterBind (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceInlineUniformBlockProperties(
+    const VkPhysicalDeviceInlineUniformBlockProperties* a,
+    const VkPhysicalDeviceInlineUniformBlockProperties* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->maxInlineUniformBlockSize) == (b->maxInlineUniformBlockSize))) {
+        onFail("a->maxInlineUniformBlockSize (Error: Value not equal)");
+    };
+    if (!((a->maxPerStageDescriptorInlineUniformBlocks) ==
+          (b->maxPerStageDescriptorInlineUniformBlocks))) {
+        onFail("a->maxPerStageDescriptorInlineUniformBlocks (Error: Value not equal)");
+    };
+    if (!((a->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks) ==
+          (b->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks))) {
+        onFail(
+            "a->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks (Error: Value not equal)");
+    };
+    if (!((a->maxDescriptorSetInlineUniformBlocks) == (b->maxDescriptorSetInlineUniformBlocks))) {
+        onFail("a->maxDescriptorSetInlineUniformBlocks (Error: Value not equal)");
+    };
+    if (!((a->maxDescriptorSetUpdateAfterBindInlineUniformBlocks) ==
+          (b->maxDescriptorSetUpdateAfterBindInlineUniformBlocks))) {
+        onFail("a->maxDescriptorSetUpdateAfterBindInlineUniformBlocks (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkWriteDescriptorSetInlineUniformBlock(
+    const VkWriteDescriptorSetInlineUniformBlock* a,
+    const VkWriteDescriptorSetInlineUniformBlock* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->dataSize) == (b->dataSize))) {
+        onFail("a->dataSize (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    const VkDescriptorPoolInlineUniformBlockCreateInfo* a,
+    const VkDescriptorPoolInlineUniformBlockCreateInfo* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->maxInlineUniformBlockBindings) == (b->maxInlineUniformBlockBindings))) {
+        onFail("a->maxInlineUniformBlockBindings (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* a,
+    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->textureCompressionASTC_HDR) == (b->textureCompressionASTC_HDR))) {
+        onFail("a->textureCompressionASTC_HDR (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkRenderingAttachmentInfo(const VkRenderingAttachmentInfo* a,
+                                          const VkRenderingAttachmentInfo* b,
+                                          OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->imageView) == (b->imageView))) {
+        onFail("a->imageView (Error: Value not equal)");
+    };
+    if (!((a->imageLayout) == (b->imageLayout))) {
+        onFail("a->imageLayout (Error: Value not equal)");
+    };
+    if (!((a->resolveMode) == (b->resolveMode))) {
+        onFail("a->resolveMode (Error: Value not equal)");
+    };
+    if (!((a->resolveImageView) == (b->resolveImageView))) {
+        onFail("a->resolveImageView (Error: Value not equal)");
+    };
+    if (!((a->resolveImageLayout) == (b->resolveImageLayout))) {
+        onFail("a->resolveImageLayout (Error: Value not equal)");
+    };
+    if (!((a->loadOp) == (b->loadOp))) {
+        onFail("a->loadOp (Error: Value not equal)");
+    };
+    if (!((a->storeOp) == (b->storeOp))) {
+        onFail("a->storeOp (Error: Value not equal)");
+    };
+    checkEqual_VkClearValue(&a->clearValue, &b->clearValue, onFail);
+}
+
+void checkEqual_VkRenderingInfo(const VkRenderingInfo* a, const VkRenderingInfo* b,
+                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+    checkEqual_VkRect2D(&a->renderArea, &b->renderArea, onFail);
+    if (!((a->layerCount) == (b->layerCount))) {
+        onFail("a->layerCount (Error: Value not equal)");
+    };
+    if (!((a->viewMask) == (b->viewMask))) {
+        onFail("a->viewMask (Error: Value not equal)");
+    };
+    if (!((a->colorAttachmentCount) == (b->colorAttachmentCount))) {
+        onFail("a->colorAttachmentCount (Error: Value not equal)");
+    };
+    if ((a->pColorAttachments) && (b->pColorAttachments)) {
+        if (!((a->colorAttachmentCount) == (b->colorAttachmentCount))) {
+            onFail("a->pColorAttachments (Error: Lengths not equal)");
+        };
+        if ((a->colorAttachmentCount) == (b->colorAttachmentCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->colorAttachmentCount; ++i) {
+                    checkEqual_VkRenderingAttachmentInfo(a->pColorAttachments + i,
+                                                         b->pColorAttachments + i, onFail);
+                }
+            }
+        }
+    }
+    if (!((!(a->pDepthAttachment) && !(b->pDepthAttachment)) ||
+          ((a->pDepthAttachment) && (b->pDepthAttachment)))) {
+        onFail("a->pDepthAttachment (Error: Mismatch in optional field)");
+    };
+    if (a->pDepthAttachment && b->pDepthAttachment) {
+        if ((a->pDepthAttachment) && (b->pDepthAttachment)) {
+            checkEqual_VkRenderingAttachmentInfo(a->pDepthAttachment, b->pDepthAttachment, onFail);
+        }
+    }
+    if (!((!(a->pStencilAttachment) && !(b->pStencilAttachment)) ||
+          ((a->pStencilAttachment) && (b->pStencilAttachment)))) {
+        onFail("a->pStencilAttachment (Error: Mismatch in optional field)");
+    };
+    if (a->pStencilAttachment && b->pStencilAttachment) {
+        if ((a->pStencilAttachment) && (b->pStencilAttachment)) {
+            checkEqual_VkRenderingAttachmentInfo(a->pStencilAttachment, b->pStencilAttachment,
+                                                 onFail);
+        }
+    }
+}
+
+void checkEqual_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo* a,
+                                              const VkPipelineRenderingCreateInfo* b,
+                                              OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->viewMask) == (b->viewMask))) {
+        onFail("a->viewMask (Error: Value not equal)");
+    };
+    if (!((a->colorAttachmentCount) == (b->colorAttachmentCount))) {
+        onFail("a->colorAttachmentCount (Error: Value not equal)");
+    };
+    if (!((!(a->pColorAttachmentFormats) && !(b->pColorAttachmentFormats)) ||
+          ((a->pColorAttachmentFormats) && (b->pColorAttachmentFormats)))) {
+        onFail("a->pColorAttachmentFormats (Error: Mismatch in optional field)");
+    };
+    if (a->pColorAttachmentFormats && b->pColorAttachmentFormats) {
+        if (!((a->colorAttachmentCount) == (b->colorAttachmentCount))) {
+            onFail("a->pColorAttachmentFormats (Error: Lengths not equal)");
+        };
+        if (!((memcmp(a->pColorAttachmentFormats, b->pColorAttachmentFormats,
+                      a->colorAttachmentCount * sizeof(const VkFormat)) == 0))) {
+            onFail("a->pColorAttachmentFormats (Error: Unequal dyn array)");
+        };
+    }
+    if (!((a->depthAttachmentFormat) == (b->depthAttachmentFormat))) {
+        onFail("a->depthAttachmentFormat (Error: Value not equal)");
+    };
+    if (!((a->stencilAttachmentFormat) == (b->stencilAttachmentFormat))) {
+        onFail("a->stencilAttachmentFormat (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceDynamicRenderingFeatures(
+    const VkPhysicalDeviceDynamicRenderingFeatures* a,
+    const VkPhysicalDeviceDynamicRenderingFeatures* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->dynamicRendering) == (b->dynamicRendering))) {
+        onFail("a->dynamicRendering (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkCommandBufferInheritanceRenderingInfo(
+    const VkCommandBufferInheritanceRenderingInfo* a,
+    const VkCommandBufferInheritanceRenderingInfo* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+    if (!((a->viewMask) == (b->viewMask))) {
+        onFail("a->viewMask (Error: Value not equal)");
+    };
+    if (!((a->colorAttachmentCount) == (b->colorAttachmentCount))) {
+        onFail("a->colorAttachmentCount (Error: Value not equal)");
+    };
+    if (!((a->colorAttachmentCount) == (b->colorAttachmentCount))) {
+        onFail("a->pColorAttachmentFormats (Error: Lengths not equal)");
+    };
+    if (!((memcmp(a->pColorAttachmentFormats, b->pColorAttachmentFormats,
+                  a->colorAttachmentCount * sizeof(const VkFormat)) == 0))) {
+        onFail("a->pColorAttachmentFormats (Error: Unequal dyn array)");
+    };
+    if (!((a->depthAttachmentFormat) == (b->depthAttachmentFormat))) {
+        onFail("a->depthAttachmentFormat (Error: Value not equal)");
+    };
+    if (!((a->stencilAttachmentFormat) == (b->stencilAttachmentFormat))) {
+        onFail("a->stencilAttachmentFormat (Error: Value not equal)");
+    };
+    if (!((a->rasterizationSamples) == (b->rasterizationSamples))) {
+        onFail("a->rasterizationSamples (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    const VkPhysicalDeviceShaderIntegerDotProductFeatures* a,
+    const VkPhysicalDeviceShaderIntegerDotProductFeatures* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->shaderIntegerDotProduct) == (b->shaderIntegerDotProduct))) {
+        onFail("a->shaderIntegerDotProduct (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    const VkPhysicalDeviceShaderIntegerDotProductProperties* a,
+    const VkPhysicalDeviceShaderIntegerDotProductProperties* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->integerDotProduct8BitUnsignedAccelerated) ==
+          (b->integerDotProduct8BitUnsignedAccelerated))) {
+        onFail("a->integerDotProduct8BitUnsignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct8BitSignedAccelerated) ==
+          (b->integerDotProduct8BitSignedAccelerated))) {
+        onFail("a->integerDotProduct8BitSignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct8BitMixedSignednessAccelerated) ==
+          (b->integerDotProduct8BitMixedSignednessAccelerated))) {
+        onFail("a->integerDotProduct8BitMixedSignednessAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct4x8BitPackedUnsignedAccelerated) ==
+          (b->integerDotProduct4x8BitPackedUnsignedAccelerated))) {
+        onFail("a->integerDotProduct4x8BitPackedUnsignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct4x8BitPackedSignedAccelerated) ==
+          (b->integerDotProduct4x8BitPackedSignedAccelerated))) {
+        onFail("a->integerDotProduct4x8BitPackedSignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct4x8BitPackedMixedSignednessAccelerated) ==
+          (b->integerDotProduct4x8BitPackedMixedSignednessAccelerated))) {
+        onFail(
+            "a->integerDotProduct4x8BitPackedMixedSignednessAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct16BitUnsignedAccelerated) ==
+          (b->integerDotProduct16BitUnsignedAccelerated))) {
+        onFail("a->integerDotProduct16BitUnsignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct16BitSignedAccelerated) ==
+          (b->integerDotProduct16BitSignedAccelerated))) {
+        onFail("a->integerDotProduct16BitSignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct16BitMixedSignednessAccelerated) ==
+          (b->integerDotProduct16BitMixedSignednessAccelerated))) {
+        onFail("a->integerDotProduct16BitMixedSignednessAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct32BitUnsignedAccelerated) ==
+          (b->integerDotProduct32BitUnsignedAccelerated))) {
+        onFail("a->integerDotProduct32BitUnsignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct32BitSignedAccelerated) ==
+          (b->integerDotProduct32BitSignedAccelerated))) {
+        onFail("a->integerDotProduct32BitSignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct32BitMixedSignednessAccelerated) ==
+          (b->integerDotProduct32BitMixedSignednessAccelerated))) {
+        onFail("a->integerDotProduct32BitMixedSignednessAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct64BitUnsignedAccelerated) ==
+          (b->integerDotProduct64BitUnsignedAccelerated))) {
+        onFail("a->integerDotProduct64BitUnsignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct64BitSignedAccelerated) ==
+          (b->integerDotProduct64BitSignedAccelerated))) {
+        onFail("a->integerDotProduct64BitSignedAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProduct64BitMixedSignednessAccelerated) ==
+          (b->integerDotProduct64BitMixedSignednessAccelerated))) {
+        onFail("a->integerDotProduct64BitMixedSignednessAccelerated (Error: Value not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating8BitSignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating8BitSignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating8BitSignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated (Error: "
+            "Value not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated (Error: "
+            "Value not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated (Error: Value "
+            "not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated "
+            "(Error: Value not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating16BitSignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating16BitSignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating16BitSignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated (Error: "
+            "Value not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating32BitSignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating32BitSignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating32BitSignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated (Error: "
+            "Value not equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating64BitSignedAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating64BitSignedAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating64BitSignedAccelerated (Error: Value not "
+            "equal)");
+    };
+    if (!((a->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated) ==
+          (b->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated))) {
+        onFail(
+            "a->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated (Error: "
+            "Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    const VkPhysicalDeviceTexelBufferAlignmentProperties* a,
+    const VkPhysicalDeviceTexelBufferAlignmentProperties* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->storageTexelBufferOffsetAlignmentBytes) ==
+          (b->storageTexelBufferOffsetAlignmentBytes))) {
+        onFail("a->storageTexelBufferOffsetAlignmentBytes (Error: Value not equal)");
+    };
+    if (!((a->storageTexelBufferOffsetSingleTexelAlignment) ==
+          (b->storageTexelBufferOffsetSingleTexelAlignment))) {
+        onFail("a->storageTexelBufferOffsetSingleTexelAlignment (Error: Value not equal)");
+    };
+    if (!((a->uniformTexelBufferOffsetAlignmentBytes) ==
+          (b->uniformTexelBufferOffsetAlignmentBytes))) {
+        onFail("a->uniformTexelBufferOffsetAlignmentBytes (Error: Value not equal)");
+    };
+    if (!((a->uniformTexelBufferOffsetSingleTexelAlignment) ==
+          (b->uniformTexelBufferOffsetSingleTexelAlignment))) {
+        onFail("a->uniformTexelBufferOffsetSingleTexelAlignment (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkFormatProperties3(const VkFormatProperties3* a, const VkFormatProperties3* b,
+                                    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->linearTilingFeatures) == (b->linearTilingFeatures))) {
+        onFail("a->linearTilingFeatures (Error: Value not equal)");
+    };
+    if (!((a->optimalTilingFeatures) == (b->optimalTilingFeatures))) {
+        onFail("a->optimalTilingFeatures (Error: Value not equal)");
+    };
+    if (!((a->bufferFeatures) == (b->bufferFeatures))) {
+        onFail("a->bufferFeatures (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features* a,
+                                                     const VkPhysicalDeviceMaintenance4Features* b,
+                                                     OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->maintenance4) == (b->maintenance4))) {
+        onFail("a->maintenance4 (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceMaintenance4Properties(
+    const VkPhysicalDeviceMaintenance4Properties* a,
+    const VkPhysicalDeviceMaintenance4Properties* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->maxBufferSize) == (b->maxBufferSize))) {
+        onFail("a->maxBufferSize (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements* a,
+                                                 const VkDeviceBufferMemoryRequirements* b,
+                                                 OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if ((a->pCreateInfo) && (b->pCreateInfo)) {
+        checkEqual_VkBufferCreateInfo(a->pCreateInfo, b->pCreateInfo, onFail);
+    }
+}
+
+void checkEqual_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements* a,
+                                                const VkDeviceImageMemoryRequirements* b,
+                                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if ((a->pCreateInfo) && (b->pCreateInfo)) {
+        checkEqual_VkImageCreateInfo(a->pCreateInfo, b->pCreateInfo, onFail);
+    }
+    if (!((a->planeAspect) == (b->planeAspect))) {
+        onFail("a->planeAspect (Error: Value not equal)");
+    };
+}
+
+#endif
 #ifdef VK_KHR_surface
 void checkEqual_VkSurfaceCapabilitiesKHR(const VkSurfaceCapabilitiesKHR* a,
                                          const VkSurfaceCapabilitiesKHR* b,
@@ -6813,9 +8449,23 @@ void checkEqual_VkWin32SurfaceCreateInfoKHR(const VkWin32SurfaceCreateInfoKHR* a
 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
 #endif
 #ifdef VK_KHR_video_queue
-void checkEqual_VkVideoQueueFamilyProperties2KHR(const VkVideoQueueFamilyProperties2KHR* a,
-                                                 const VkVideoQueueFamilyProperties2KHR* b,
-                                                 OnFailCompareFunc onFail) {
+void checkEqual_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    const VkQueueFamilyQueryResultStatusPropertiesKHR* a,
+    const VkQueueFamilyQueryResultStatusPropertiesKHR* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->queryResultStatusSupport) == (b->queryResultStatusSupport))) {
+        onFail("a->queryResultStatusSupport (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkQueueFamilyVideoPropertiesKHR(const VkQueueFamilyVideoPropertiesKHR* a,
+                                                const VkQueueFamilyVideoPropertiesKHR* b,
+                                                OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
@@ -6827,8 +8477,8 @@ void checkEqual_VkVideoQueueFamilyProperties2KHR(const VkVideoQueueFamilyPropert
     };
 }
 
-void checkEqual_VkVideoProfileKHR(const VkVideoProfileKHR* a, const VkVideoProfileKHR* b,
-                                  OnFailCompareFunc onFail) {
+void checkEqual_VkVideoProfileInfoKHR(const VkVideoProfileInfoKHR* a,
+                                      const VkVideoProfileInfoKHR* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
@@ -6849,8 +8499,9 @@ void checkEqual_VkVideoProfileKHR(const VkVideoProfileKHR* a, const VkVideoProfi
     };
 }
 
-void checkEqual_VkVideoProfilesKHR(const VkVideoProfilesKHR* a, const VkVideoProfilesKHR* b,
-                                   OnFailCompareFunc onFail) {
+void checkEqual_VkVideoProfileListInfoKHR(const VkVideoProfileListInfoKHR* a,
+                                          const VkVideoProfileListInfoKHR* b,
+                                          OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
@@ -6861,7 +8512,16 @@ void checkEqual_VkVideoProfilesKHR(const VkVideoProfilesKHR* a, const VkVideoPro
         onFail("a->profileCount (Error: Value not equal)");
     };
     if ((a->pProfiles) && (b->pProfiles)) {
-        checkEqual_VkVideoProfileKHR(a->pProfiles, b->pProfiles, onFail);
+        if (!((a->profileCount) == (b->profileCount))) {
+            onFail("a->pProfiles (Error: Lengths not equal)");
+        };
+        if ((a->profileCount) == (b->profileCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->profileCount; ++i) {
+                    checkEqual_VkVideoProfileInfoKHR(a->pProfiles + i, b->pProfiles + i, onFail);
+                }
+            }
+        }
     }
 }
 
@@ -6873,8 +8533,8 @@ void checkEqual_VkVideoCapabilitiesKHR(const VkVideoCapabilitiesKHR* a,
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->capabilityFlags) == (b->capabilityFlags))) {
-        onFail("a->capabilityFlags (Error: Value not equal)");
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
     };
     if (!((a->minBitstreamBufferOffsetAlignment) == (b->minBitstreamBufferOffsetAlignment))) {
         onFail("a->minBitstreamBufferOffsetAlignment (Error: Value not equal)");
@@ -6882,16 +8542,16 @@ void checkEqual_VkVideoCapabilitiesKHR(const VkVideoCapabilitiesKHR* a,
     if (!((a->minBitstreamBufferSizeAlignment) == (b->minBitstreamBufferSizeAlignment))) {
         onFail("a->minBitstreamBufferSizeAlignment (Error: Value not equal)");
     };
-    checkEqual_VkExtent2D(&a->videoPictureExtentGranularity, &b->videoPictureExtentGranularity,
-                          onFail);
-    checkEqual_VkExtent2D(&a->minExtent, &b->minExtent, onFail);
-    checkEqual_VkExtent2D(&a->maxExtent, &b->maxExtent, onFail);
-    if (!((a->maxReferencePicturesSlotsCount) == (b->maxReferencePicturesSlotsCount))) {
-        onFail("a->maxReferencePicturesSlotsCount (Error: Value not equal)");
+    checkEqual_VkExtent2D(&a->pictureAccessGranularity, &b->pictureAccessGranularity, onFail);
+    checkEqual_VkExtent2D(&a->minCodedExtent, &b->minCodedExtent, onFail);
+    checkEqual_VkExtent2D(&a->maxCodedExtent, &b->maxCodedExtent, onFail);
+    if (!((a->maxDpbSlots) == (b->maxDpbSlots))) {
+        onFail("a->maxDpbSlots (Error: Value not equal)");
     };
-    if (!((a->maxReferencePicturesActiveCount) == (b->maxReferencePicturesActiveCount))) {
-        onFail("a->maxReferencePicturesActiveCount (Error: Value not equal)");
+    if (!((a->maxActiveReferencePictures) == (b->maxActiveReferencePictures))) {
+        onFail("a->maxActiveReferencePictures (Error: Value not equal)");
     };
+    checkEqual_VkExtensionProperties(&a->stdHeaderVersion, &b->stdHeaderVersion, onFail);
 }
 
 void checkEqual_VkPhysicalDeviceVideoFormatInfoKHR(const VkPhysicalDeviceVideoFormatInfoKHR* a,
@@ -6906,9 +8566,6 @@ void checkEqual_VkPhysicalDeviceVideoFormatInfoKHR(const VkPhysicalDeviceVideoFo
     if (!((a->imageUsage) == (b->imageUsage))) {
         onFail("a->imageUsage (Error: Value not equal)");
     };
-    if ((a->pVideoProfiles) && (b->pVideoProfiles)) {
-        checkEqual_VkVideoProfilesKHR(a->pVideoProfiles, b->pVideoProfiles, onFail);
-    }
 }
 
 void checkEqual_VkVideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR* a,
@@ -6923,11 +8580,24 @@ void checkEqual_VkVideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR* a,
     if (!((a->format) == (b->format))) {
         onFail("a->format (Error: Value not equal)");
     };
+    checkEqual_VkComponentMapping(&a->componentMapping, &b->componentMapping, onFail);
+    if (!((a->imageCreateFlags) == (b->imageCreateFlags))) {
+        onFail("a->imageCreateFlags (Error: Value not equal)");
+    };
+    if (!((a->imageType) == (b->imageType))) {
+        onFail("a->imageType (Error: Value not equal)");
+    };
+    if (!((a->imageTiling) == (b->imageTiling))) {
+        onFail("a->imageTiling (Error: Value not equal)");
+    };
+    if (!((a->imageUsageFlags) == (b->imageUsageFlags))) {
+        onFail("a->imageUsageFlags (Error: Value not equal)");
+    };
 }
 
-void checkEqual_VkVideoPictureResourceKHR(const VkVideoPictureResourceKHR* a,
-                                          const VkVideoPictureResourceKHR* b,
-                                          OnFailCompareFunc onFail) {
+void checkEqual_VkVideoPictureResourceInfoKHR(const VkVideoPictureResourceInfoKHR* a,
+                                              const VkVideoPictureResourceInfoKHR* b,
+                                              OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
@@ -6944,9 +8614,9 @@ void checkEqual_VkVideoPictureResourceKHR(const VkVideoPictureResourceKHR* a,
     };
 }
 
-void checkEqual_VkVideoReferenceSlotKHR(const VkVideoReferenceSlotKHR* a,
-                                        const VkVideoReferenceSlotKHR* b,
-                                        OnFailCompareFunc onFail) {
+void checkEqual_VkVideoReferenceSlotInfoKHR(const VkVideoReferenceSlotInfoKHR* a,
+                                            const VkVideoReferenceSlotInfoKHR* b,
+                                            OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
@@ -6956,14 +8626,21 @@ void checkEqual_VkVideoReferenceSlotKHR(const VkVideoReferenceSlotKHR* a,
     if (!((a->slotIndex) == (b->slotIndex))) {
         onFail("a->slotIndex (Error: Value not equal)");
     };
-    if ((a->pPictureResource) && (b->pPictureResource)) {
-        checkEqual_VkVideoPictureResourceKHR(a->pPictureResource, b->pPictureResource, onFail);
+    if (!((!(a->pPictureResource) && !(b->pPictureResource)) ||
+          ((a->pPictureResource) && (b->pPictureResource)))) {
+        onFail("a->pPictureResource (Error: Mismatch in optional field)");
+    };
+    if (a->pPictureResource && b->pPictureResource) {
+        if ((a->pPictureResource) && (b->pPictureResource)) {
+            checkEqual_VkVideoPictureResourceInfoKHR(a->pPictureResource, b->pPictureResource,
+                                                     onFail);
+        }
     }
 }
 
-void checkEqual_VkVideoGetMemoryPropertiesKHR(const VkVideoGetMemoryPropertiesKHR* a,
-                                              const VkVideoGetMemoryPropertiesKHR* b,
-                                              OnFailCompareFunc onFail) {
+void checkEqual_VkVideoSessionMemoryRequirementsKHR(const VkVideoSessionMemoryRequirementsKHR* a,
+                                                    const VkVideoSessionMemoryRequirementsKHR* b,
+                                                    OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
@@ -6973,13 +8650,12 @@ void checkEqual_VkVideoGetMemoryPropertiesKHR(const VkVideoGetMemoryPropertiesKH
     if (!((a->memoryBindIndex) == (b->memoryBindIndex))) {
         onFail("a->memoryBindIndex (Error: Value not equal)");
     };
-    if ((a->pMemoryRequirements) && (b->pMemoryRequirements)) {
-        checkEqual_VkMemoryRequirements2(a->pMemoryRequirements, b->pMemoryRequirements, onFail);
-    }
+    checkEqual_VkMemoryRequirements(&a->memoryRequirements, &b->memoryRequirements, onFail);
 }
 
-void checkEqual_VkVideoBindMemoryKHR(const VkVideoBindMemoryKHR* a, const VkVideoBindMemoryKHR* b,
-                                     OnFailCompareFunc onFail) {
+void checkEqual_VkBindVideoSessionMemoryInfoKHR(const VkBindVideoSessionMemoryInfoKHR* a,
+                                                const VkBindVideoSessionMemoryInfoKHR* b,
+                                                OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
@@ -7016,21 +8692,24 @@ void checkEqual_VkVideoSessionCreateInfoKHR(const VkVideoSessionCreateInfoKHR* a
         onFail("a->flags (Error: Value not equal)");
     };
     if ((a->pVideoProfile) && (b->pVideoProfile)) {
-        checkEqual_VkVideoProfileKHR(a->pVideoProfile, b->pVideoProfile, onFail);
+        checkEqual_VkVideoProfileInfoKHR(a->pVideoProfile, b->pVideoProfile, onFail);
     }
     if (!((a->pictureFormat) == (b->pictureFormat))) {
         onFail("a->pictureFormat (Error: Value not equal)");
     };
     checkEqual_VkExtent2D(&a->maxCodedExtent, &b->maxCodedExtent, onFail);
-    if (!((a->referencePicturesFormat) == (b->referencePicturesFormat))) {
-        onFail("a->referencePicturesFormat (Error: Value not equal)");
+    if (!((a->referencePictureFormat) == (b->referencePictureFormat))) {
+        onFail("a->referencePictureFormat (Error: Value not equal)");
     };
-    if (!((a->maxReferencePicturesSlotsCount) == (b->maxReferencePicturesSlotsCount))) {
-        onFail("a->maxReferencePicturesSlotsCount (Error: Value not equal)");
+    if (!((a->maxDpbSlots) == (b->maxDpbSlots))) {
+        onFail("a->maxDpbSlots (Error: Value not equal)");
     };
-    if (!((a->maxReferencePicturesActiveCount) == (b->maxReferencePicturesActiveCount))) {
-        onFail("a->maxReferencePicturesActiveCount (Error: Value not equal)");
+    if (!((a->maxActiveReferencePictures) == (b->maxActiveReferencePictures))) {
+        onFail("a->maxActiveReferencePictures (Error: Value not equal)");
     };
+    if ((a->pStdHeaderVersion) && (b->pStdHeaderVersion)) {
+        checkEqual_VkExtensionProperties(a->pStdHeaderVersion, b->pStdHeaderVersion, onFail);
+    }
 }
 
 void checkEqual_VkVideoSessionParametersCreateInfoKHR(
@@ -7042,6 +8721,9 @@ void checkEqual_VkVideoSessionParametersCreateInfoKHR(
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
     if (!((a->videoSessionParametersTemplate) == (b->videoSessionParametersTemplate))) {
         onFail("a->videoSessionParametersTemplate (Error: Value not equal)");
     };
@@ -7076,9 +8758,6 @@ void checkEqual_VkVideoBeginCodingInfoKHR(const VkVideoBeginCodingInfoKHR* a,
     if (!((a->flags) == (b->flags))) {
         onFail("a->flags (Error: Value not equal)");
     };
-    if (!((a->codecQualityPreset) == (b->codecQualityPreset))) {
-        onFail("a->codecQualityPreset (Error: Value not equal)");
-    };
     if (!((a->videoSession) == (b->videoSession))) {
         onFail("a->videoSession (Error: Value not equal)");
     };
@@ -7095,8 +8774,8 @@ void checkEqual_VkVideoBeginCodingInfoKHR(const VkVideoBeginCodingInfoKHR* a,
         if ((a->referenceSlotCount) == (b->referenceSlotCount)) {
             if (a) {
                 for (uint32_t i = 0; i < (uint32_t)a->referenceSlotCount; ++i) {
-                    checkEqual_VkVideoReferenceSlotKHR(a->pReferenceSlots + i,
-                                                       b->pReferenceSlots + i, onFail);
+                    checkEqual_VkVideoReferenceSlotInfoKHR(a->pReferenceSlots + i,
+                                                           b->pReferenceSlots + i, onFail);
                 }
             }
         }
@@ -7133,6 +8812,34 @@ void checkEqual_VkVideoCodingControlInfoKHR(const VkVideoCodingControlInfoKHR* a
 
 #endif
 #ifdef VK_KHR_video_decode_queue
+void checkEqual_VkVideoDecodeCapabilitiesKHR(const VkVideoDecodeCapabilitiesKHR* a,
+                                             const VkVideoDecodeCapabilitiesKHR* b,
+                                             OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkVideoDecodeUsageInfoKHR(const VkVideoDecodeUsageInfoKHR* a,
+                                          const VkVideoDecodeUsageInfoKHR* b,
+                                          OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->videoUsageHints) == (b->videoUsageHints))) {
+        onFail("a->videoUsageHints (Error: Value not equal)");
+    };
+}
+
 void checkEqual_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* a, const VkVideoDecodeInfoKHR* b,
                                      OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
@@ -7144,8 +8851,6 @@ void checkEqual_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* a, const VkVide
     if (!((a->flags) == (b->flags))) {
         onFail("a->flags (Error: Value not equal)");
     };
-    checkEqual_VkOffset2D(&a->codedOffset, &b->codedOffset, onFail);
-    checkEqual_VkExtent2D(&a->codedExtent, &b->codedExtent, onFail);
     if (!((a->srcBuffer) == (b->srcBuffer))) {
         onFail("a->srcBuffer (Error: Value not equal)");
     };
@@ -7155,9 +8860,11 @@ void checkEqual_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* a, const VkVide
     if (!((a->srcBufferRange) == (b->srcBufferRange))) {
         onFail("a->srcBufferRange (Error: Value not equal)");
     };
-    checkEqual_VkVideoPictureResourceKHR(&a->dstPictureResource, &b->dstPictureResource, onFail);
+    checkEqual_VkVideoPictureResourceInfoKHR(&a->dstPictureResource, &b->dstPictureResource,
+                                             onFail);
     if ((a->pSetupReferenceSlot) && (b->pSetupReferenceSlot)) {
-        checkEqual_VkVideoReferenceSlotKHR(a->pSetupReferenceSlot, b->pSetupReferenceSlot, onFail);
+        checkEqual_VkVideoReferenceSlotInfoKHR(a->pSetupReferenceSlot, b->pSetupReferenceSlot,
+                                               onFail);
     }
     if (!((a->referenceSlotCount) == (b->referenceSlotCount))) {
         onFail("a->referenceSlotCount (Error: Value not equal)");
@@ -7169,8 +8876,8 @@ void checkEqual_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* a, const VkVide
         if ((a->referenceSlotCount) == (b->referenceSlotCount)) {
             if (a) {
                 for (uint32_t i = 0; i < (uint32_t)a->referenceSlotCount; ++i) {
-                    checkEqual_VkVideoReferenceSlotKHR(a->pReferenceSlots + i,
-                                                       b->pReferenceSlots + i, onFail);
+                    checkEqual_VkVideoReferenceSlotInfoKHR(a->pReferenceSlots + i,
+                                                           b->pReferenceSlots + i, onFail);
                 }
             }
         }
@@ -7178,176 +8885,139 @@ void checkEqual_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* a, const VkVide
 }
 
 #endif
-#ifdef VK_KHR_dynamic_rendering
-void checkEqual_VkRenderingAttachmentInfoKHR(const VkRenderingAttachmentInfoKHR* a,
-                                             const VkRenderingAttachmentInfoKHR* b,
-                                             OnFailCompareFunc onFail) {
+#ifdef VK_KHR_video_decode_h264
+void checkEqual_VkVideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR* a,
+                                                const VkVideoDecodeH264ProfileInfoKHR* b,
+                                                OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->imageView) == (b->imageView))) {
-        onFail("a->imageView (Error: Value not equal)");
-    };
-    if (!((a->imageLayout) == (b->imageLayout))) {
-        onFail("a->imageLayout (Error: Value not equal)");
-    };
-    if (!((a->resolveMode) == (b->resolveMode))) {
-        onFail("a->resolveMode (Error: Value not equal)");
-    };
-    if (!((a->resolveImageView) == (b->resolveImageView))) {
-        onFail("a->resolveImageView (Error: Value not equal)");
-    };
-    if (!((a->resolveImageLayout) == (b->resolveImageLayout))) {
-        onFail("a->resolveImageLayout (Error: Value not equal)");
-    };
-    if (!((a->loadOp) == (b->loadOp))) {
-        onFail("a->loadOp (Error: Value not equal)");
+    if (!((a->stdProfileIdc) == (b->stdProfileIdc))) {
+        onFail("a->stdProfileIdc (Error: Value not equal)");
     };
-    if (!((a->storeOp) == (b->storeOp))) {
-        onFail("a->storeOp (Error: Value not equal)");
+    if (!((a->pictureLayout) == (b->pictureLayout))) {
+        onFail("a->pictureLayout (Error: Value not equal)");
     };
-    checkEqual_VkClearValue(&a->clearValue, &b->clearValue, onFail);
 }
 
-void checkEqual_VkRenderingInfoKHR(const VkRenderingInfoKHR* a, const VkRenderingInfoKHR* b,
-                                   OnFailCompareFunc onFail) {
+void checkEqual_VkVideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR* a,
+                                                 const VkVideoDecodeH264CapabilitiesKHR* b,
+                                                 OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->flags) == (b->flags))) {
-        onFail("a->flags (Error: Value not equal)");
+    if (!((a->maxLevelIdc) == (b->maxLevelIdc))) {
+        onFail("a->maxLevelIdc (Error: Value not equal)");
     };
-    checkEqual_VkRect2D(&a->renderArea, &b->renderArea, onFail);
-    if (!((a->layerCount) == (b->layerCount))) {
-        onFail("a->layerCount (Error: Value not equal)");
-    };
-    if (!((a->viewMask) == (b->viewMask))) {
-        onFail("a->viewMask (Error: Value not equal)");
-    };
-    if (!((a->colorAttachmentCount) == (b->colorAttachmentCount))) {
-        onFail("a->colorAttachmentCount (Error: Value not equal)");
-    };
-    if ((a->pColorAttachments) && (b->pColorAttachments)) {
-        if (!((a->colorAttachmentCount) == (b->colorAttachmentCount))) {
-            onFail("a->pColorAttachments (Error: Lengths not equal)");
-        };
-        if ((a->colorAttachmentCount) == (b->colorAttachmentCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->colorAttachmentCount; ++i) {
-                    checkEqual_VkRenderingAttachmentInfoKHR(a->pColorAttachments + i,
-                                                            b->pColorAttachments + i, onFail);
-                }
-            }
-        }
-    }
-    if (!((!(a->pDepthAttachment) && !(b->pDepthAttachment)) ||
-          ((a->pDepthAttachment) && (b->pDepthAttachment)))) {
-        onFail("a->pDepthAttachment (Error: Mismatch in optional field)");
-    };
-    if (a->pDepthAttachment && b->pDepthAttachment) {
-        if ((a->pDepthAttachment) && (b->pDepthAttachment)) {
-            checkEqual_VkRenderingAttachmentInfoKHR(a->pDepthAttachment, b->pDepthAttachment,
-                                                    onFail);
-        }
-    }
-    if (!((!(a->pStencilAttachment) && !(b->pStencilAttachment)) ||
-          ((a->pStencilAttachment) && (b->pStencilAttachment)))) {
-        onFail("a->pStencilAttachment (Error: Mismatch in optional field)");
-    };
-    if (a->pStencilAttachment && b->pStencilAttachment) {
-        if ((a->pStencilAttachment) && (b->pStencilAttachment)) {
-            checkEqual_VkRenderingAttachmentInfoKHR(a->pStencilAttachment, b->pStencilAttachment,
-                                                    onFail);
-        }
-    }
+    checkEqual_VkOffset2D(&a->fieldOffsetGranularity, &b->fieldOffsetGranularity, onFail);
 }
 
-void checkEqual_VkPipelineRenderingCreateInfoKHR(const VkPipelineRenderingCreateInfoKHR* a,
-                                                 const VkPipelineRenderingCreateInfoKHR* b,
-                                                 OnFailCompareFunc onFail) {
+void checkEqual_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    const VkVideoDecodeH264SessionParametersAddInfoKHR* a,
+    const VkVideoDecodeH264SessionParametersAddInfoKHR* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->viewMask) == (b->viewMask))) {
-        onFail("a->viewMask (Error: Value not equal)");
+    if (!((a->stdSPSCount) == (b->stdSPSCount))) {
+        onFail("a->stdSPSCount (Error: Value not equal)");
     };
-    if (!((a->colorAttachmentCount) == (b->colorAttachmentCount))) {
-        onFail("a->colorAttachmentCount (Error: Value not equal)");
+    if (!((a->stdSPSCount) == (b->stdSPSCount))) {
+        onFail("a->pStdSPSs (Error: Lengths not equal)");
     };
-    if (!((a->colorAttachmentCount) == (b->colorAttachmentCount))) {
-        onFail("a->pColorAttachmentFormats (Error: Lengths not equal)");
+    if (!((memcmp(a->pStdSPSs, b->pStdSPSs,
+                  a->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet)) == 0))) {
+        onFail("a->pStdSPSs (Error: Unequal dyn array)");
     };
-    if (!((memcmp(a->pColorAttachmentFormats, b->pColorAttachmentFormats,
-                  a->colorAttachmentCount * sizeof(const VkFormat)) == 0))) {
-        onFail("a->pColorAttachmentFormats (Error: Unequal dyn array)");
+    if (!((a->stdPPSCount) == (b->stdPPSCount))) {
+        onFail("a->stdPPSCount (Error: Value not equal)");
     };
-    if (!((a->depthAttachmentFormat) == (b->depthAttachmentFormat))) {
-        onFail("a->depthAttachmentFormat (Error: Value not equal)");
+    if (!((a->stdPPSCount) == (b->stdPPSCount))) {
+        onFail("a->pStdPPSs (Error: Lengths not equal)");
     };
-    if (!((a->stencilAttachmentFormat) == (b->stencilAttachmentFormat))) {
-        onFail("a->stencilAttachmentFormat (Error: Value not equal)");
+    if (!((memcmp(a->pStdPPSs, b->pStdPPSs,
+                  a->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet)) == 0))) {
+        onFail("a->pStdPPSs (Error: Unequal dyn array)");
     };
 }
 
-void checkEqual_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
-    const VkPhysicalDeviceDynamicRenderingFeaturesKHR* a,
-    const VkPhysicalDeviceDynamicRenderingFeaturesKHR* b, OnFailCompareFunc onFail) {
+void checkEqual_VkVideoDecodeH264SessionParametersCreateInfoKHR(
+    const VkVideoDecodeH264SessionParametersCreateInfoKHR* a,
+    const VkVideoDecodeH264SessionParametersCreateInfoKHR* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->dynamicRendering) == (b->dynamicRendering))) {
-        onFail("a->dynamicRendering (Error: Value not equal)");
+    if (!((a->maxStdSPSCount) == (b->maxStdSPSCount))) {
+        onFail("a->maxStdSPSCount (Error: Value not equal)");
+    };
+    if (!((a->maxStdPPSCount) == (b->maxStdPPSCount))) {
+        onFail("a->maxStdPPSCount (Error: Value not equal)");
     };
+    if (!((!(a->pParametersAddInfo) && !(b->pParametersAddInfo)) ||
+          ((a->pParametersAddInfo) && (b->pParametersAddInfo)))) {
+        onFail("a->pParametersAddInfo (Error: Mismatch in optional field)");
+    };
+    if (a->pParametersAddInfo && b->pParametersAddInfo) {
+        if ((a->pParametersAddInfo) && (b->pParametersAddInfo)) {
+            checkEqual_VkVideoDecodeH264SessionParametersAddInfoKHR(a->pParametersAddInfo,
+                                                                    b->pParametersAddInfo, onFail);
+        }
+    }
 }
 
-void checkEqual_VkCommandBufferInheritanceRenderingInfoKHR(
-    const VkCommandBufferInheritanceRenderingInfoKHR* a,
-    const VkCommandBufferInheritanceRenderingInfoKHR* b, OnFailCompareFunc onFail) {
+void checkEqual_VkVideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR* a,
+                                                const VkVideoDecodeH264PictureInfoKHR* b,
+                                                OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->flags) == (b->flags))) {
-        onFail("a->flags (Error: Value not equal)");
-    };
-    if (!((a->viewMask) == (b->viewMask))) {
-        onFail("a->viewMask (Error: Value not equal)");
-    };
-    if (!((a->colorAttachmentCount) == (b->colorAttachmentCount))) {
-        onFail("a->colorAttachmentCount (Error: Value not equal)");
+    if (!((memcmp(a->pStdPictureInfo, b->pStdPictureInfo,
+                  sizeof(const StdVideoDecodeH264PictureInfo)) == 0))) {
+        onFail("a->pStdPictureInfo (Error: Unequal dyn array)");
     };
-    if (!((a->colorAttachmentCount) == (b->colorAttachmentCount))) {
-        onFail("a->pColorAttachmentFormats (Error: Lengths not equal)");
+    if (!((a->sliceCount) == (b->sliceCount))) {
+        onFail("a->sliceCount (Error: Value not equal)");
     };
-    if (!((memcmp(a->pColorAttachmentFormats, b->pColorAttachmentFormats,
-                  a->colorAttachmentCount * sizeof(const VkFormat)) == 0))) {
-        onFail("a->pColorAttachmentFormats (Error: Unequal dyn array)");
+    if (!((a->sliceCount) == (b->sliceCount))) {
+        onFail("a->pSliceOffsets (Error: Lengths not equal)");
     };
-    if (!((a->depthAttachmentFormat) == (b->depthAttachmentFormat))) {
-        onFail("a->depthAttachmentFormat (Error: Value not equal)");
+    if (!((memcmp(a->pSliceOffsets, b->pSliceOffsets, a->sliceCount * sizeof(const uint32_t)) ==
+           0))) {
+        onFail("a->pSliceOffsets (Error: Unequal dyn array)");
     };
-    if (!((a->stencilAttachmentFormat) == (b->stencilAttachmentFormat))) {
-        onFail("a->stencilAttachmentFormat (Error: Value not equal)");
+}
+
+void checkEqual_VkVideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR* a,
+                                                const VkVideoDecodeH264DpbSlotInfoKHR* b,
+                                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
     };
-    if (!((a->rasterizationSamples) == (b->rasterizationSamples))) {
-        onFail("a->rasterizationSamples (Error: Value not equal)");
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((memcmp(a->pStdReferenceInfo, b->pStdReferenceInfo,
+                  sizeof(const StdVideoDecodeH264ReferenceInfo)) == 0))) {
+        onFail("a->pStdReferenceInfo (Error: Unequal dyn array)");
     };
 }
 
+#endif
+#ifdef VK_KHR_dynamic_rendering
 void checkEqual_VkRenderingFragmentShadingRateAttachmentInfoKHR(
     const VkRenderingFragmentShadingRateAttachmentInfoKHR* a,
     const VkRenderingFragmentShadingRateAttachmentInfoKHR* b, OnFailCompareFunc onFail) {
@@ -8393,6 +10063,195 @@ void checkEqual_VkPhysicalDeviceShaderClockFeaturesKHR(
 }
 
 #endif
+#ifdef VK_KHR_video_decode_h265
+void checkEqual_VkVideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR* a,
+                                                const VkVideoDecodeH265ProfileInfoKHR* b,
+                                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->stdProfileIdc) == (b->stdProfileIdc))) {
+        onFail("a->stdProfileIdc (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkVideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR* a,
+                                                 const VkVideoDecodeH265CapabilitiesKHR* b,
+                                                 OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->maxLevelIdc) == (b->maxLevelIdc))) {
+        onFail("a->maxLevelIdc (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    const VkVideoDecodeH265SessionParametersAddInfoKHR* a,
+    const VkVideoDecodeH265SessionParametersAddInfoKHR* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->stdVPSCount) == (b->stdVPSCount))) {
+        onFail("a->stdVPSCount (Error: Value not equal)");
+    };
+    if (!((a->stdVPSCount) == (b->stdVPSCount))) {
+        onFail("a->pStdVPSs (Error: Lengths not equal)");
+    };
+    if (!((memcmp(a->pStdVPSs, b->pStdVPSs,
+                  a->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet)) == 0))) {
+        onFail("a->pStdVPSs (Error: Unequal dyn array)");
+    };
+    if (!((a->stdSPSCount) == (b->stdSPSCount))) {
+        onFail("a->stdSPSCount (Error: Value not equal)");
+    };
+    if (!((a->stdSPSCount) == (b->stdSPSCount))) {
+        onFail("a->pStdSPSs (Error: Lengths not equal)");
+    };
+    if (!((memcmp(a->pStdSPSs, b->pStdSPSs,
+                  a->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet)) == 0))) {
+        onFail("a->pStdSPSs (Error: Unequal dyn array)");
+    };
+    if (!((a->stdPPSCount) == (b->stdPPSCount))) {
+        onFail("a->stdPPSCount (Error: Value not equal)");
+    };
+    if (!((a->stdPPSCount) == (b->stdPPSCount))) {
+        onFail("a->pStdPPSs (Error: Lengths not equal)");
+    };
+    if (!((memcmp(a->pStdPPSs, b->pStdPPSs,
+                  a->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet)) == 0))) {
+        onFail("a->pStdPPSs (Error: Unequal dyn array)");
+    };
+}
+
+void checkEqual_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    const VkVideoDecodeH265SessionParametersCreateInfoKHR* a,
+    const VkVideoDecodeH265SessionParametersCreateInfoKHR* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->maxStdVPSCount) == (b->maxStdVPSCount))) {
+        onFail("a->maxStdVPSCount (Error: Value not equal)");
+    };
+    if (!((a->maxStdSPSCount) == (b->maxStdSPSCount))) {
+        onFail("a->maxStdSPSCount (Error: Value not equal)");
+    };
+    if (!((a->maxStdPPSCount) == (b->maxStdPPSCount))) {
+        onFail("a->maxStdPPSCount (Error: Value not equal)");
+    };
+    if (!((!(a->pParametersAddInfo) && !(b->pParametersAddInfo)) ||
+          ((a->pParametersAddInfo) && (b->pParametersAddInfo)))) {
+        onFail("a->pParametersAddInfo (Error: Mismatch in optional field)");
+    };
+    if (a->pParametersAddInfo && b->pParametersAddInfo) {
+        if ((a->pParametersAddInfo) && (b->pParametersAddInfo)) {
+            checkEqual_VkVideoDecodeH265SessionParametersAddInfoKHR(a->pParametersAddInfo,
+                                                                    b->pParametersAddInfo, onFail);
+        }
+    }
+}
+
+void checkEqual_VkVideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR* a,
+                                                const VkVideoDecodeH265PictureInfoKHR* b,
+                                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((memcmp(a->pStdPictureInfo, b->pStdPictureInfo,
+                  sizeof(const StdVideoDecodeH265PictureInfo)) == 0))) {
+        onFail("a->pStdPictureInfo (Error: Unequal dyn array)");
+    };
+    if (!((a->sliceSegmentCount) == (b->sliceSegmentCount))) {
+        onFail("a->sliceSegmentCount (Error: Value not equal)");
+    };
+    if (!((a->sliceSegmentCount) == (b->sliceSegmentCount))) {
+        onFail("a->pSliceSegmentOffsets (Error: Lengths not equal)");
+    };
+    if (!((memcmp(a->pSliceSegmentOffsets, b->pSliceSegmentOffsets,
+                  a->sliceSegmentCount * sizeof(const uint32_t)) == 0))) {
+        onFail("a->pSliceSegmentOffsets (Error: Unequal dyn array)");
+    };
+}
+
+void checkEqual_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR* a,
+                                                const VkVideoDecodeH265DpbSlotInfoKHR* b,
+                                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((memcmp(a->pStdReferenceInfo, b->pStdReferenceInfo,
+                  sizeof(const StdVideoDecodeH265ReferenceInfo)) == 0))) {
+        onFail("a->pStdReferenceInfo (Error: Unequal dyn array)");
+    };
+}
+
+#endif
+#ifdef VK_KHR_global_priority
+void checkEqual_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    const VkDeviceQueueGlobalPriorityCreateInfoKHR* a,
+    const VkDeviceQueueGlobalPriorityCreateInfoKHR* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->globalPriority) == (b->globalPriority))) {
+        onFail("a->globalPriority (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* a,
+    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->globalPriorityQuery) == (b->globalPriorityQuery))) {
+        onFail("a->globalPriorityQuery (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    const VkQueueFamilyGlobalPriorityPropertiesKHR* a,
+    const VkQueueFamilyGlobalPriorityPropertiesKHR* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->priorityCount) == (b->priorityCount))) {
+        onFail("a->priorityCount (Error: Value not equal)");
+    };
+    if (!((memcmp(a->priorities, b->priorities,
+                  VK_MAX_GLOBAL_PRIORITY_SIZE_KHR * sizeof(VkQueueGlobalPriorityKHR)) == 0))) {
+        onFail("a->priorities (Error: Unequal static array)");
+    };
+}
+
+#endif
 #ifdef VK_KHR_driver_properties
 #endif
 #ifdef VK_KHR_shader_float_controls
@@ -8406,20 +10265,6 @@ void checkEqual_VkPhysicalDeviceShaderClockFeaturesKHR(
 #ifdef VK_KHR_vulkan_memory_model
 #endif
 #ifdef VK_KHR_shader_terminate_invocation
-void checkEqual_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
-    const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* a,
-    const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->shaderTerminateInvocation) == (b->shaderTerminateInvocation))) {
-        onFail("a->shaderTerminateInvocation (Error: Value not equal)");
-    };
-}
-
 #endif
 #ifdef VK_KHR_fragment_shading_rate
 void checkEqual_VkFragmentShadingRateAttachmentInfoKHR(
@@ -8741,184 +10586,48 @@ void checkEqual_VkPipelineExecutableInternalRepresentationKHR(
 }
 
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-void checkEqual_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* a,
-    const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* b, OnFailCompareFunc onFail) {
+#ifdef VK_KHR_map_memory2
+void checkEqual_VkMemoryMapInfoKHR(const VkMemoryMapInfoKHR* a, const VkMemoryMapInfoKHR* b,
+                                   OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->shaderIntegerDotProduct) == (b->shaderIntegerDotProduct))) {
-        onFail("a->shaderIntegerDotProduct (Error: Value not equal)");
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+    if (!((a->memory) == (b->memory))) {
+        onFail("a->memory (Error: Value not equal)");
+    };
+    if (!((a->offset) == (b->offset))) {
+        onFail("a->offset (Error: Value not equal)");
+    };
+    if (!((a->size) == (b->size))) {
+        onFail("a->size (Error: Value not equal)");
     };
 }
 
-void checkEqual_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* a,
-    const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* b, OnFailCompareFunc onFail) {
+void checkEqual_VkMemoryUnmapInfoKHR(const VkMemoryUnmapInfoKHR* a, const VkMemoryUnmapInfoKHR* b,
+                                     OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->integerDotProduct8BitUnsignedAccelerated) ==
-          (b->integerDotProduct8BitUnsignedAccelerated))) {
-        onFail("a->integerDotProduct8BitUnsignedAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct8BitSignedAccelerated) ==
-          (b->integerDotProduct8BitSignedAccelerated))) {
-        onFail("a->integerDotProduct8BitSignedAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct8BitMixedSignednessAccelerated) ==
-          (b->integerDotProduct8BitMixedSignednessAccelerated))) {
-        onFail("a->integerDotProduct8BitMixedSignednessAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct4x8BitPackedUnsignedAccelerated) ==
-          (b->integerDotProduct4x8BitPackedUnsignedAccelerated))) {
-        onFail("a->integerDotProduct4x8BitPackedUnsignedAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct4x8BitPackedSignedAccelerated) ==
-          (b->integerDotProduct4x8BitPackedSignedAccelerated))) {
-        onFail("a->integerDotProduct4x8BitPackedSignedAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct4x8BitPackedMixedSignednessAccelerated) ==
-          (b->integerDotProduct4x8BitPackedMixedSignednessAccelerated))) {
-        onFail(
-            "a->integerDotProduct4x8BitPackedMixedSignednessAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct16BitUnsignedAccelerated) ==
-          (b->integerDotProduct16BitUnsignedAccelerated))) {
-        onFail("a->integerDotProduct16BitUnsignedAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct16BitSignedAccelerated) ==
-          (b->integerDotProduct16BitSignedAccelerated))) {
-        onFail("a->integerDotProduct16BitSignedAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct16BitMixedSignednessAccelerated) ==
-          (b->integerDotProduct16BitMixedSignednessAccelerated))) {
-        onFail("a->integerDotProduct16BitMixedSignednessAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct32BitUnsignedAccelerated) ==
-          (b->integerDotProduct32BitUnsignedAccelerated))) {
-        onFail("a->integerDotProduct32BitUnsignedAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct32BitSignedAccelerated) ==
-          (b->integerDotProduct32BitSignedAccelerated))) {
-        onFail("a->integerDotProduct32BitSignedAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct32BitMixedSignednessAccelerated) ==
-          (b->integerDotProduct32BitMixedSignednessAccelerated))) {
-        onFail("a->integerDotProduct32BitMixedSignednessAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct64BitUnsignedAccelerated) ==
-          (b->integerDotProduct64BitUnsignedAccelerated))) {
-        onFail("a->integerDotProduct64BitUnsignedAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct64BitSignedAccelerated) ==
-          (b->integerDotProduct64BitSignedAccelerated))) {
-        onFail("a->integerDotProduct64BitSignedAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProduct64BitMixedSignednessAccelerated) ==
-          (b->integerDotProduct64BitMixedSignednessAccelerated))) {
-        onFail("a->integerDotProduct64BitMixedSignednessAccelerated (Error: Value not equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating8BitUnsignedAccelerated (Error: Value not "
-            "equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating8BitSignedAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating8BitSignedAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating8BitSignedAccelerated (Error: Value not "
-            "equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated (Error: "
-            "Value not equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated (Error: "
-            "Value not equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated (Error: Value "
-            "not equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated "
-            "(Error: Value not equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating16BitUnsignedAccelerated (Error: Value not "
-            "equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating16BitSignedAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating16BitSignedAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating16BitSignedAccelerated (Error: Value not "
-            "equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated (Error: "
-            "Value not equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating32BitUnsignedAccelerated (Error: Value not "
-            "equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating32BitSignedAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating32BitSignedAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating32BitSignedAccelerated (Error: Value not "
-            "equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated (Error: "
-            "Value not equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating64BitUnsignedAccelerated (Error: Value not "
-            "equal)");
-    };
-    if (!((a->integerDotProductAccumulatingSaturating64BitSignedAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating64BitSignedAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating64BitSignedAccelerated (Error: Value not "
-            "equal)");
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
     };
-    if (!((a->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated) ==
-          (b->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated))) {
-        onFail(
-            "a->integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated (Error: "
-            "Value not equal)");
+    if (!((a->memory) == (b->memory))) {
+        onFail("a->memory (Error: Value not equal)");
     };
 }
 
 #endif
+#ifdef VK_KHR_shader_integer_dot_product
+#endif
 #ifdef VK_KHR_pipeline_library
 void checkEqual_VkPipelineLibraryCreateInfoKHR(const VkPipelineLibraryCreateInfoKHR* a,
                                                const VkPipelineLibraryCreateInfoKHR* b,
@@ -9000,19 +10709,26 @@ void checkEqual_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR* a, const VkVide
     if (!((a->qualityLevel) == (b->qualityLevel))) {
         onFail("a->qualityLevel (Error: Value not equal)");
     };
-    checkEqual_VkExtent2D(&a->codedExtent, &b->codedExtent, onFail);
-    if (!((a->dstBitstreamBuffer) == (b->dstBitstreamBuffer))) {
-        onFail("a->dstBitstreamBuffer (Error: Value not equal)");
+    if (!((a->dstBuffer) == (b->dstBuffer))) {
+        onFail("a->dstBuffer (Error: Value not equal)");
     };
-    if (!((a->dstBitstreamBufferOffset) == (b->dstBitstreamBufferOffset))) {
-        onFail("a->dstBitstreamBufferOffset (Error: Value not equal)");
+    if (!((a->dstBufferOffset) == (b->dstBufferOffset))) {
+        onFail("a->dstBufferOffset (Error: Value not equal)");
     };
-    if (!((a->dstBitstreamBufferMaxRange) == (b->dstBitstreamBufferMaxRange))) {
-        onFail("a->dstBitstreamBufferMaxRange (Error: Value not equal)");
+    if (!((a->dstBufferRange) == (b->dstBufferRange))) {
+        onFail("a->dstBufferRange (Error: Value not equal)");
     };
-    checkEqual_VkVideoPictureResourceKHR(&a->srcPictureResource, &b->srcPictureResource, onFail);
-    if ((a->pSetupReferenceSlot) && (b->pSetupReferenceSlot)) {
-        checkEqual_VkVideoReferenceSlotKHR(a->pSetupReferenceSlot, b->pSetupReferenceSlot, onFail);
+    checkEqual_VkVideoPictureResourceInfoKHR(&a->srcPictureResource, &b->srcPictureResource,
+                                             onFail);
+    if (!((!(a->pSetupReferenceSlot) && !(b->pSetupReferenceSlot)) ||
+          ((a->pSetupReferenceSlot) && (b->pSetupReferenceSlot)))) {
+        onFail("a->pSetupReferenceSlot (Error: Mismatch in optional field)");
+    };
+    if (a->pSetupReferenceSlot && b->pSetupReferenceSlot) {
+        if ((a->pSetupReferenceSlot) && (b->pSetupReferenceSlot)) {
+            checkEqual_VkVideoReferenceSlotInfoKHR(a->pSetupReferenceSlot, b->pSetupReferenceSlot,
+                                                   onFail);
+        }
     }
     if (!((a->referenceSlotCount) == (b->referenceSlotCount))) {
         onFail("a->referenceSlotCount (Error: Value not equal)");
@@ -9024,17 +10740,20 @@ void checkEqual_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR* a, const VkVide
         if ((a->referenceSlotCount) == (b->referenceSlotCount)) {
             if (a) {
                 for (uint32_t i = 0; i < (uint32_t)a->referenceSlotCount; ++i) {
-                    checkEqual_VkVideoReferenceSlotKHR(a->pReferenceSlots + i,
-                                                       b->pReferenceSlots + i, onFail);
+                    checkEqual_VkVideoReferenceSlotInfoKHR(a->pReferenceSlots + i,
+                                                           b->pReferenceSlots + i, onFail);
                 }
             }
         }
     }
+    if (!((a->precedingExternallyEncodedBytes) == (b->precedingExternallyEncodedBytes))) {
+        onFail("a->precedingExternallyEncodedBytes (Error: Value not equal)");
+    };
 }
 
-void checkEqual_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR* a,
-                                                const VkVideoEncodeRateControlInfoKHR* b,
-                                                OnFailCompareFunc onFail) {
+void checkEqual_VkVideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR* a,
+                                             const VkVideoEncodeCapabilitiesKHR* b,
+                                             OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
@@ -9044,52 +10763,37 @@ void checkEqual_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlIn
     if (!((a->flags) == (b->flags))) {
         onFail("a->flags (Error: Value not equal)");
     };
-    if (!((a->rateControlMode) == (b->rateControlMode))) {
-        onFail("a->rateControlMode (Error: Value not equal)");
-    };
-    if (!((a->averageBitrate) == (b->averageBitrate))) {
-        onFail("a->averageBitrate (Error: Value not equal)");
-    };
-    if (!((a->peakToAverageBitrateRatio) == (b->peakToAverageBitrateRatio))) {
-        onFail("a->peakToAverageBitrateRatio (Error: Value not equal)");
+    if (!((a->rateControlModes) == (b->rateControlModes))) {
+        onFail("a->rateControlModes (Error: Value not equal)");
     };
-    if (!((a->frameRateNumerator) == (b->frameRateNumerator))) {
-        onFail("a->frameRateNumerator (Error: Value not equal)");
+    if (!((a->maxRateControlLayers) == (b->maxRateControlLayers))) {
+        onFail("a->maxRateControlLayers (Error: Value not equal)");
     };
-    if (!((a->frameRateDenominator) == (b->frameRateDenominator))) {
-        onFail("a->frameRateDenominator (Error: Value not equal)");
+    if (!((a->maxQualityLevels) == (b->maxQualityLevels))) {
+        onFail("a->maxQualityLevels (Error: Value not equal)");
     };
-    if (!((a->virtualBufferSizeInMs) == (b->virtualBufferSizeInMs))) {
-        onFail("a->virtualBufferSizeInMs (Error: Value not equal)");
+    checkEqual_VkExtent2D(&a->inputImageDataFillAlignment, &b->inputImageDataFillAlignment, onFail);
+    if (!((a->supportedEncodeFeedbackFlags) == (b->supportedEncodeFeedbackFlags))) {
+        onFail("a->supportedEncodeFeedbackFlags (Error: Value not equal)");
     };
 }
 
-#endif
-#ifdef VK_KHR_synchronization2
-void checkEqual_VkMemoryBarrier2KHR(const VkMemoryBarrier2KHR* a, const VkMemoryBarrier2KHR* b,
-                                    OnFailCompareFunc onFail) {
+void checkEqual_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* a,
+    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->srcStageMask) == (b->srcStageMask))) {
-        onFail("a->srcStageMask (Error: Value not equal)");
-    };
-    if (!((a->srcAccessMask) == (b->srcAccessMask))) {
-        onFail("a->srcAccessMask (Error: Value not equal)");
-    };
-    if (!((a->dstStageMask) == (b->dstStageMask))) {
-        onFail("a->dstStageMask (Error: Value not equal)");
-    };
-    if (!((a->dstAccessMask) == (b->dstAccessMask))) {
-        onFail("a->dstAccessMask (Error: Value not equal)");
+    if (!((a->encodeFeedbackFlags) == (b->encodeFeedbackFlags))) {
+        onFail("a->encodeFeedbackFlags (Error: Value not equal)");
     };
 }
 
-void checkEqual_VkBufferMemoryBarrier2KHR(const VkBufferMemoryBarrier2KHR* a,
-                                          const VkBufferMemoryBarrier2KHR* b,
+void checkEqual_VkVideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR* a,
+                                          const VkVideoEncodeUsageInfoKHR* b,
                                           OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
@@ -9097,278 +10801,140 @@ void checkEqual_VkBufferMemoryBarrier2KHR(const VkBufferMemoryBarrier2KHR* a,
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->srcStageMask) == (b->srcStageMask))) {
-        onFail("a->srcStageMask (Error: Value not equal)");
-    };
-    if (!((a->srcAccessMask) == (b->srcAccessMask))) {
-        onFail("a->srcAccessMask (Error: Value not equal)");
-    };
-    if (!((a->dstStageMask) == (b->dstStageMask))) {
-        onFail("a->dstStageMask (Error: Value not equal)");
-    };
-    if (!((a->dstAccessMask) == (b->dstAccessMask))) {
-        onFail("a->dstAccessMask (Error: Value not equal)");
-    };
-    if (!((a->srcQueueFamilyIndex) == (b->srcQueueFamilyIndex))) {
-        onFail("a->srcQueueFamilyIndex (Error: Value not equal)");
-    };
-    if (!((a->dstQueueFamilyIndex) == (b->dstQueueFamilyIndex))) {
-        onFail("a->dstQueueFamilyIndex (Error: Value not equal)");
-    };
-    if (!((a->buffer) == (b->buffer))) {
-        onFail("a->buffer (Error: Value not equal)");
+    if (!((a->videoUsageHints) == (b->videoUsageHints))) {
+        onFail("a->videoUsageHints (Error: Value not equal)");
     };
-    if (!((a->offset) == (b->offset))) {
-        onFail("a->offset (Error: Value not equal)");
+    if (!((a->videoContentHints) == (b->videoContentHints))) {
+        onFail("a->videoContentHints (Error: Value not equal)");
     };
-    if (!((a->size) == (b->size))) {
-        onFail("a->size (Error: Value not equal)");
+    if (!((a->tuningMode) == (b->tuningMode))) {
+        onFail("a->tuningMode (Error: Value not equal)");
     };
 }
 
-void checkEqual_VkImageMemoryBarrier2KHR(const VkImageMemoryBarrier2KHR* a,
-                                         const VkImageMemoryBarrier2KHR* b,
-                                         OnFailCompareFunc onFail) {
+void checkEqual_VkVideoEncodeRateControlLayerInfoKHR(const VkVideoEncodeRateControlLayerInfoKHR* a,
+                                                     const VkVideoEncodeRateControlLayerInfoKHR* b,
+                                                     OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->srcStageMask) == (b->srcStageMask))) {
-        onFail("a->srcStageMask (Error: Value not equal)");
-    };
-    if (!((a->srcAccessMask) == (b->srcAccessMask))) {
-        onFail("a->srcAccessMask (Error: Value not equal)");
-    };
-    if (!((a->dstStageMask) == (b->dstStageMask))) {
-        onFail("a->dstStageMask (Error: Value not equal)");
-    };
-    if (!((a->dstAccessMask) == (b->dstAccessMask))) {
-        onFail("a->dstAccessMask (Error: Value not equal)");
+    if (!((a->averageBitrate) == (b->averageBitrate))) {
+        onFail("a->averageBitrate (Error: Value not equal)");
     };
-    if (!((a->oldLayout) == (b->oldLayout))) {
-        onFail("a->oldLayout (Error: Value not equal)");
+    if (!((a->maxBitrate) == (b->maxBitrate))) {
+        onFail("a->maxBitrate (Error: Value not equal)");
     };
-    if (!((a->newLayout) == (b->newLayout))) {
-        onFail("a->newLayout (Error: Value not equal)");
+    if (!((a->frameRateNumerator) == (b->frameRateNumerator))) {
+        onFail("a->frameRateNumerator (Error: Value not equal)");
     };
-    if (!((a->srcQueueFamilyIndex) == (b->srcQueueFamilyIndex))) {
-        onFail("a->srcQueueFamilyIndex (Error: Value not equal)");
+    if (!((a->frameRateDenominator) == (b->frameRateDenominator))) {
+        onFail("a->frameRateDenominator (Error: Value not equal)");
     };
-    if (!((a->dstQueueFamilyIndex) == (b->dstQueueFamilyIndex))) {
-        onFail("a->dstQueueFamilyIndex (Error: Value not equal)");
+    if (!((a->virtualBufferSizeInMs) == (b->virtualBufferSizeInMs))) {
+        onFail("a->virtualBufferSizeInMs (Error: Value not equal)");
     };
-    if (!((a->image) == (b->image))) {
-        onFail("a->image (Error: Value not equal)");
+    if (!((a->initialVirtualBufferSizeInMs) == (b->initialVirtualBufferSizeInMs))) {
+        onFail("a->initialVirtualBufferSizeInMs (Error: Value not equal)");
     };
-    checkEqual_VkImageSubresourceRange(&a->subresourceRange, &b->subresourceRange, onFail);
 }
 
-void checkEqual_VkDependencyInfoKHR(const VkDependencyInfoKHR* a, const VkDependencyInfoKHR* b,
-                                    OnFailCompareFunc onFail) {
+void checkEqual_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR* a,
+                                                const VkVideoEncodeRateControlInfoKHR* b,
+                                                OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->dependencyFlags) == (b->dependencyFlags))) {
-        onFail("a->dependencyFlags (Error: Value not equal)");
-    };
-    if (!((a->memoryBarrierCount) == (b->memoryBarrierCount))) {
-        onFail("a->memoryBarrierCount (Error: Value not equal)");
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
     };
-    if ((a->pMemoryBarriers) && (b->pMemoryBarriers)) {
-        if (!((a->memoryBarrierCount) == (b->memoryBarrierCount))) {
-            onFail("a->pMemoryBarriers (Error: Lengths not equal)");
-        };
-        if ((a->memoryBarrierCount) == (b->memoryBarrierCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->memoryBarrierCount; ++i) {
-                    checkEqual_VkMemoryBarrier2KHR(a->pMemoryBarriers + i, b->pMemoryBarriers + i,
-                                                   onFail);
-                }
-            }
-        }
-    }
-    if (!((a->bufferMemoryBarrierCount) == (b->bufferMemoryBarrierCount))) {
-        onFail("a->bufferMemoryBarrierCount (Error: Value not equal)");
+    if (!((a->rateControlMode) == (b->rateControlMode))) {
+        onFail("a->rateControlMode (Error: Value not equal)");
     };
-    if ((a->pBufferMemoryBarriers) && (b->pBufferMemoryBarriers)) {
-        if (!((a->bufferMemoryBarrierCount) == (b->bufferMemoryBarrierCount))) {
-            onFail("a->pBufferMemoryBarriers (Error: Lengths not equal)");
-        };
-        if ((a->bufferMemoryBarrierCount) == (b->bufferMemoryBarrierCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->bufferMemoryBarrierCount; ++i) {
-                    checkEqual_VkBufferMemoryBarrier2KHR(a->pBufferMemoryBarriers + i,
-                                                         b->pBufferMemoryBarriers + i, onFail);
-                }
-            }
-        }
-    }
-    if (!((a->imageMemoryBarrierCount) == (b->imageMemoryBarrierCount))) {
-        onFail("a->imageMemoryBarrierCount (Error: Value not equal)");
+    if (!((a->layerCount) == (b->layerCount))) {
+        onFail("a->layerCount (Error: Value not equal)");
     };
-    if ((a->pImageMemoryBarriers) && (b->pImageMemoryBarriers)) {
-        if (!((a->imageMemoryBarrierCount) == (b->imageMemoryBarrierCount))) {
-            onFail("a->pImageMemoryBarriers (Error: Lengths not equal)");
+    if ((a->pLayers) && (b->pLayers)) {
+        if (!((a->layerCount) == (b->layerCount))) {
+            onFail("a->pLayers (Error: Lengths not equal)");
         };
-        if ((a->imageMemoryBarrierCount) == (b->imageMemoryBarrierCount)) {
+        if ((a->layerCount) == (b->layerCount)) {
             if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->imageMemoryBarrierCount; ++i) {
-                    checkEqual_VkImageMemoryBarrier2KHR(a->pImageMemoryBarriers + i,
-                                                        b->pImageMemoryBarriers + i, onFail);
+                for (uint32_t i = 0; i < (uint32_t)a->layerCount; ++i) {
+                    checkEqual_VkVideoEncodeRateControlLayerInfoKHR(a->pLayers + i, b->pLayers + i,
+                                                                    onFail);
                 }
             }
         }
     }
 }
 
-void checkEqual_VkSemaphoreSubmitInfoKHR(const VkSemaphoreSubmitInfoKHR* a,
-                                         const VkSemaphoreSubmitInfoKHR* b,
-                                         OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->semaphore) == (b->semaphore))) {
-        onFail("a->semaphore (Error: Value not equal)");
-    };
-    if (!((a->value) == (b->value))) {
-        onFail("a->value (Error: Value not equal)");
-    };
-    if (!((a->stageMask) == (b->stageMask))) {
-        onFail("a->stageMask (Error: Value not equal)");
-    };
-    if (!((a->deviceIndex) == (b->deviceIndex))) {
-        onFail("a->deviceIndex (Error: Value not equal)");
-    };
-}
-
-void checkEqual_VkCommandBufferSubmitInfoKHR(const VkCommandBufferSubmitInfoKHR* a,
-                                             const VkCommandBufferSubmitInfoKHR* b,
-                                             OnFailCompareFunc onFail) {
+#endif
+#ifdef VK_KHR_synchronization2
+void checkEqual_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV* a,
+                                                     const VkQueueFamilyCheckpointProperties2NV* b,
+                                                     OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->commandBuffer) == (b->commandBuffer))) {
-        onFail("a->commandBuffer (Error: Value not equal)");
-    };
-    if (!((a->deviceMask) == (b->deviceMask))) {
-        onFail("a->deviceMask (Error: Value not equal)");
+    if (!((a->checkpointExecutionStageMask) == (b->checkpointExecutionStageMask))) {
+        onFail("a->checkpointExecutionStageMask (Error: Value not equal)");
     };
 }
 
-void checkEqual_VkSubmitInfo2KHR(const VkSubmitInfo2KHR* a, const VkSubmitInfo2KHR* b,
-                                 OnFailCompareFunc onFail) {
+void checkEqual_VkCheckpointData2NV(const VkCheckpointData2NV* a, const VkCheckpointData2NV* b,
+                                    OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->flags) == (b->flags))) {
-        onFail("a->flags (Error: Value not equal)");
-    };
-    if (!((a->waitSemaphoreInfoCount) == (b->waitSemaphoreInfoCount))) {
-        onFail("a->waitSemaphoreInfoCount (Error: Value not equal)");
-    };
-    if ((a->pWaitSemaphoreInfos) && (b->pWaitSemaphoreInfos)) {
-        if (!((a->waitSemaphoreInfoCount) == (b->waitSemaphoreInfoCount))) {
-            onFail("a->pWaitSemaphoreInfos (Error: Lengths not equal)");
-        };
-        if ((a->waitSemaphoreInfoCount) == (b->waitSemaphoreInfoCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->waitSemaphoreInfoCount; ++i) {
-                    checkEqual_VkSemaphoreSubmitInfoKHR(a->pWaitSemaphoreInfos + i,
-                                                        b->pWaitSemaphoreInfos + i, onFail);
-                }
-            }
-        }
-    }
-    if (!((a->commandBufferInfoCount) == (b->commandBufferInfoCount))) {
-        onFail("a->commandBufferInfoCount (Error: Value not equal)");
-    };
-    if ((a->pCommandBufferInfos) && (b->pCommandBufferInfos)) {
-        if (!((a->commandBufferInfoCount) == (b->commandBufferInfoCount))) {
-            onFail("a->pCommandBufferInfos (Error: Lengths not equal)");
-        };
-        if ((a->commandBufferInfoCount) == (b->commandBufferInfoCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->commandBufferInfoCount; ++i) {
-                    checkEqual_VkCommandBufferSubmitInfoKHR(a->pCommandBufferInfos + i,
-                                                            b->pCommandBufferInfos + i, onFail);
-                }
-            }
-        }
-    }
-    if (!((a->signalSemaphoreInfoCount) == (b->signalSemaphoreInfoCount))) {
-        onFail("a->signalSemaphoreInfoCount (Error: Value not equal)");
-    };
-    if ((a->pSignalSemaphoreInfos) && (b->pSignalSemaphoreInfos)) {
-        if (!((a->signalSemaphoreInfoCount) == (b->signalSemaphoreInfoCount))) {
-            onFail("a->pSignalSemaphoreInfos (Error: Lengths not equal)");
-        };
-        if ((a->signalSemaphoreInfoCount) == (b->signalSemaphoreInfoCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->signalSemaphoreInfoCount; ++i) {
-                    checkEqual_VkSemaphoreSubmitInfoKHR(a->pSignalSemaphoreInfos + i,
-                                                        b->pSignalSemaphoreInfos + i, onFail);
-                }
-            }
-        }
-    }
-}
-
-void checkEqual_VkPhysicalDeviceSynchronization2FeaturesKHR(
-    const VkPhysicalDeviceSynchronization2FeaturesKHR* a,
-    const VkPhysicalDeviceSynchronization2FeaturesKHR* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
+    if (!((a->stage) == (b->stage))) {
+        onFail("a->stage (Error: Value not equal)");
     };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->synchronization2) == (b->synchronization2))) {
-        onFail("a->synchronization2 (Error: Value not equal)");
+    if (!((!(a->pCheckpointMarker) && !(b->pCheckpointMarker)) ||
+          ((a->pCheckpointMarker) && (b->pCheckpointMarker)))) {
+        onFail("a->pCheckpointMarker (Error: Mismatch in optional field)");
     };
 }
 
-void checkEqual_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV* a,
-                                                     const VkQueueFamilyCheckpointProperties2NV* b,
-                                                     OnFailCompareFunc onFail) {
+#endif
+#ifdef VK_KHR_fragment_shader_barycentric
+void checkEqual_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* a,
+    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->checkpointExecutionStageMask) == (b->checkpointExecutionStageMask))) {
-        onFail("a->checkpointExecutionStageMask (Error: Value not equal)");
+    if (!((a->fragmentShaderBarycentric) == (b->fragmentShaderBarycentric))) {
+        onFail("a->fragmentShaderBarycentric (Error: Value not equal)");
     };
 }
 
-void checkEqual_VkCheckpointData2NV(const VkCheckpointData2NV* a, const VkCheckpointData2NV* b,
-                                    OnFailCompareFunc onFail) {
+void checkEqual_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* a,
+    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->stage) == (b->stage))) {
-        onFail("a->stage (Error: Value not equal)");
-    };
-    if (!((!(a->pCheckpointMarker) && !(b->pCheckpointMarker)) ||
-          ((a->pCheckpointMarker) && (b->pCheckpointMarker)))) {
-        onFail("a->pCheckpointMarker (Error: Mismatch in optional field)");
+    if (!((a->triStripVertexOrderIndependentOfProvokingVertex) ==
+          (b->triStripVertexOrderIndependentOfProvokingVertex))) {
+        onFail("a->triStripVertexOrderIndependentOfProvokingVertex (Error: Value not equal)");
     };
 }
 
@@ -9391,20 +10957,6 @@ void checkEqual_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
-void checkEqual_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* a,
-    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->shaderZeroInitializeWorkgroupMemory) == (b->shaderZeroInitializeWorkgroupMemory))) {
-        onFail("a->shaderZeroInitializeWorkgroupMemory (Error: Value not equal)");
-    };
-}
-
 #endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
 void checkEqual_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
@@ -9435,430 +10987,160 @@ void checkEqual_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_copy_commands2
-void checkEqual_VkBufferCopy2KHR(const VkBufferCopy2KHR* a, const VkBufferCopy2KHR* b,
-                                 OnFailCompareFunc onFail) {
+#endif
+#ifdef VK_KHR_format_feature_flags2
+#endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+void checkEqual_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* a,
+    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->srcOffset) == (b->srcOffset))) {
-        onFail("a->srcOffset (Error: Value not equal)");
-    };
-    if (!((a->dstOffset) == (b->dstOffset))) {
-        onFail("a->dstOffset (Error: Value not equal)");
+    if (!((a->rayTracingMaintenance1) == (b->rayTracingMaintenance1))) {
+        onFail("a->rayTracingMaintenance1 (Error: Value not equal)");
     };
-    if (!((a->size) == (b->size))) {
-        onFail("a->size (Error: Value not equal)");
+    if (!((a->rayTracingPipelineTraceRaysIndirect2) == (b->rayTracingPipelineTraceRaysIndirect2))) {
+        onFail("a->rayTracingPipelineTraceRaysIndirect2 (Error: Value not equal)");
     };
 }
 
-void checkEqual_VkCopyBufferInfo2KHR(const VkCopyBufferInfo2KHR* a, const VkCopyBufferInfo2KHR* b,
-                                     OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
+void checkEqual_VkTraceRaysIndirectCommand2KHR(const VkTraceRaysIndirectCommand2KHR* a,
+                                               const VkTraceRaysIndirectCommand2KHR* b,
+                                               OnFailCompareFunc onFail) {
+    if (!((a->raygenShaderRecordAddress) == (b->raygenShaderRecordAddress))) {
+        onFail("a->raygenShaderRecordAddress (Error: Value not equal)");
     };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->srcBuffer) == (b->srcBuffer))) {
-        onFail("a->srcBuffer (Error: Value not equal)");
+    if (!((a->raygenShaderRecordSize) == (b->raygenShaderRecordSize))) {
+        onFail("a->raygenShaderRecordSize (Error: Value not equal)");
     };
-    if (!((a->dstBuffer) == (b->dstBuffer))) {
-        onFail("a->dstBuffer (Error: Value not equal)");
+    if (!((a->missShaderBindingTableAddress) == (b->missShaderBindingTableAddress))) {
+        onFail("a->missShaderBindingTableAddress (Error: Value not equal)");
     };
-    if (!((a->regionCount) == (b->regionCount))) {
-        onFail("a->regionCount (Error: Value not equal)");
+    if (!((a->missShaderBindingTableSize) == (b->missShaderBindingTableSize))) {
+        onFail("a->missShaderBindingTableSize (Error: Value not equal)");
     };
-    if ((a->pRegions) && (b->pRegions)) {
-        if (!((a->regionCount) == (b->regionCount))) {
-            onFail("a->pRegions (Error: Lengths not equal)");
-        };
-        if ((a->regionCount) == (b->regionCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->regionCount; ++i) {
-                    checkEqual_VkBufferCopy2KHR(a->pRegions + i, b->pRegions + i, onFail);
-                }
-            }
-        }
-    }
-}
-
-void checkEqual_VkImageCopy2KHR(const VkImageCopy2KHR* a, const VkImageCopy2KHR* b,
-                                OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
+    if (!((a->missShaderBindingTableStride) == (b->missShaderBindingTableStride))) {
+        onFail("a->missShaderBindingTableStride (Error: Value not equal)");
     };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    checkEqual_VkImageSubresourceLayers(&a->srcSubresource, &b->srcSubresource, onFail);
-    checkEqual_VkOffset3D(&a->srcOffset, &b->srcOffset, onFail);
-    checkEqual_VkImageSubresourceLayers(&a->dstSubresource, &b->dstSubresource, onFail);
-    checkEqual_VkOffset3D(&a->dstOffset, &b->dstOffset, onFail);
-    checkEqual_VkExtent3D(&a->extent, &b->extent, onFail);
-}
-
-void checkEqual_VkCopyImageInfo2KHR(const VkCopyImageInfo2KHR* a, const VkCopyImageInfo2KHR* b,
-                                    OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
+    if (!((a->hitShaderBindingTableAddress) == (b->hitShaderBindingTableAddress))) {
+        onFail("a->hitShaderBindingTableAddress (Error: Value not equal)");
     };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->srcImage) == (b->srcImage))) {
-        onFail("a->srcImage (Error: Value not equal)");
+    if (!((a->hitShaderBindingTableSize) == (b->hitShaderBindingTableSize))) {
+        onFail("a->hitShaderBindingTableSize (Error: Value not equal)");
     };
-    if (!((a->srcImageLayout) == (b->srcImageLayout))) {
-        onFail("a->srcImageLayout (Error: Value not equal)");
+    if (!((a->hitShaderBindingTableStride) == (b->hitShaderBindingTableStride))) {
+        onFail("a->hitShaderBindingTableStride (Error: Value not equal)");
     };
-    if (!((a->dstImage) == (b->dstImage))) {
-        onFail("a->dstImage (Error: Value not equal)");
+    if (!((a->callableShaderBindingTableAddress) == (b->callableShaderBindingTableAddress))) {
+        onFail("a->callableShaderBindingTableAddress (Error: Value not equal)");
     };
-    if (!((a->dstImageLayout) == (b->dstImageLayout))) {
-        onFail("a->dstImageLayout (Error: Value not equal)");
+    if (!((a->callableShaderBindingTableSize) == (b->callableShaderBindingTableSize))) {
+        onFail("a->callableShaderBindingTableSize (Error: Value not equal)");
     };
-    if (!((a->regionCount) == (b->regionCount))) {
-        onFail("a->regionCount (Error: Value not equal)");
+    if (!((a->callableShaderBindingTableStride) == (b->callableShaderBindingTableStride))) {
+        onFail("a->callableShaderBindingTableStride (Error: Value not equal)");
     };
-    if ((a->pRegions) && (b->pRegions)) {
-        if (!((a->regionCount) == (b->regionCount))) {
-            onFail("a->pRegions (Error: Lengths not equal)");
-        };
-        if ((a->regionCount) == (b->regionCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->regionCount; ++i) {
-                    checkEqual_VkImageCopy2KHR(a->pRegions + i, b->pRegions + i, onFail);
-                }
-            }
-        }
-    }
-}
-
-void checkEqual_VkBufferImageCopy2KHR(const VkBufferImageCopy2KHR* a,
-                                      const VkBufferImageCopy2KHR* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->bufferOffset) == (b->bufferOffset))) {
-        onFail("a->bufferOffset (Error: Value not equal)");
+    if (!((a->width) == (b->width))) {
+        onFail("a->width (Error: Value not equal)");
     };
-    if (!((a->bufferRowLength) == (b->bufferRowLength))) {
-        onFail("a->bufferRowLength (Error: Value not equal)");
+    if (!((a->height) == (b->height))) {
+        onFail("a->height (Error: Value not equal)");
     };
-    if (!((a->bufferImageHeight) == (b->bufferImageHeight))) {
-        onFail("a->bufferImageHeight (Error: Value not equal)");
+    if (!((a->depth) == (b->depth))) {
+        onFail("a->depth (Error: Value not equal)");
     };
-    checkEqual_VkImageSubresourceLayers(&a->imageSubresource, &b->imageSubresource, onFail);
-    checkEqual_VkOffset3D(&a->imageOffset, &b->imageOffset, onFail);
-    checkEqual_VkExtent3D(&a->imageExtent, &b->imageExtent, onFail);
 }
 
-void checkEqual_VkCopyBufferToImageInfo2KHR(const VkCopyBufferToImageInfo2KHR* a,
-                                            const VkCopyBufferToImageInfo2KHR* b,
-                                            OnFailCompareFunc onFail) {
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
+#ifdef VK_KHR_maintenance4
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+void checkEqual_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* a,
+    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->srcBuffer) == (b->srcBuffer))) {
-        onFail("a->srcBuffer (Error: Value not equal)");
-    };
-    if (!((a->dstImage) == (b->dstImage))) {
-        onFail("a->dstImage (Error: Value not equal)");
+    if (!((a->rayTracingPositionFetch) == (b->rayTracingPositionFetch))) {
+        onFail("a->rayTracingPositionFetch (Error: Value not equal)");
     };
-    if (!((a->dstImageLayout) == (b->dstImageLayout))) {
-        onFail("a->dstImageLayout (Error: Value not equal)");
-    };
-    if (!((a->regionCount) == (b->regionCount))) {
-        onFail("a->regionCount (Error: Value not equal)");
-    };
-    if ((a->pRegions) && (b->pRegions)) {
-        if (!((a->regionCount) == (b->regionCount))) {
-            onFail("a->pRegions (Error: Lengths not equal)");
-        };
-        if ((a->regionCount) == (b->regionCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->regionCount; ++i) {
-                    checkEqual_VkBufferImageCopy2KHR(a->pRegions + i, b->pRegions + i, onFail);
-                }
-            }
-        }
-    }
 }
 
-void checkEqual_VkCopyImageToBufferInfo2KHR(const VkCopyImageToBufferInfo2KHR* a,
-                                            const VkCopyImageToBufferInfo2KHR* b,
+#endif
+#ifdef VK_ANDROID_native_buffer
+void checkEqual_VkNativeBufferUsage2ANDROID(const VkNativeBufferUsage2ANDROID* a,
+                                            const VkNativeBufferUsage2ANDROID* b,
                                             OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->srcImage) == (b->srcImage))) {
-        onFail("a->srcImage (Error: Value not equal)");
-    };
-    if (!((a->srcImageLayout) == (b->srcImageLayout))) {
-        onFail("a->srcImageLayout (Error: Value not equal)");
-    };
-    if (!((a->dstBuffer) == (b->dstBuffer))) {
-        onFail("a->dstBuffer (Error: Value not equal)");
-    };
-    if (!((a->regionCount) == (b->regionCount))) {
-        onFail("a->regionCount (Error: Value not equal)");
-    };
-    if ((a->pRegions) && (b->pRegions)) {
-        if (!((a->regionCount) == (b->regionCount))) {
-            onFail("a->pRegions (Error: Lengths not equal)");
-        };
-        if ((a->regionCount) == (b->regionCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->regionCount; ++i) {
-                    checkEqual_VkBufferImageCopy2KHR(a->pRegions + i, b->pRegions + i, onFail);
-                }
-            }
-        }
-    }
-}
-
-void checkEqual_VkImageBlit2KHR(const VkImageBlit2KHR* a, const VkImageBlit2KHR* b,
-                                OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    checkEqual_VkImageSubresourceLayers(&a->srcSubresource, &b->srcSubresource, onFail);
-    if (!((2) == (2))) {
-        onFail("a->srcOffsets (Error: Lengths not equal)");
-    };
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        checkEqual_VkOffset3D(a->srcOffsets + i, b->srcOffsets + i, onFail);
-    }
-    checkEqual_VkImageSubresourceLayers(&a->dstSubresource, &b->dstSubresource, onFail);
-    if (!((2) == (2))) {
-        onFail("a->dstOffsets (Error: Lengths not equal)");
-    };
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        checkEqual_VkOffset3D(a->dstOffsets + i, b->dstOffsets + i, onFail);
-    }
-}
-
-void checkEqual_VkBlitImageInfo2KHR(const VkBlitImageInfo2KHR* a, const VkBlitImageInfo2KHR* b,
-                                    OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->srcImage) == (b->srcImage))) {
-        onFail("a->srcImage (Error: Value not equal)");
-    };
-    if (!((a->srcImageLayout) == (b->srcImageLayout))) {
-        onFail("a->srcImageLayout (Error: Value not equal)");
-    };
-    if (!((a->dstImage) == (b->dstImage))) {
-        onFail("a->dstImage (Error: Value not equal)");
-    };
-    if (!((a->dstImageLayout) == (b->dstImageLayout))) {
-        onFail("a->dstImageLayout (Error: Value not equal)");
-    };
-    if (!((a->regionCount) == (b->regionCount))) {
-        onFail("a->regionCount (Error: Value not equal)");
-    };
-    if ((a->pRegions) && (b->pRegions)) {
-        if (!((a->regionCount) == (b->regionCount))) {
-            onFail("a->pRegions (Error: Lengths not equal)");
-        };
-        if ((a->regionCount) == (b->regionCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->regionCount; ++i) {
-                    checkEqual_VkImageBlit2KHR(a->pRegions + i, b->pRegions + i, onFail);
-                }
-            }
-        }
-    }
-    if (!((a->filter) == (b->filter))) {
-        onFail("a->filter (Error: Value not equal)");
+    if (!((a->consumer) == (b->consumer))) {
+        onFail("a->consumer (Error: Value not equal)");
     };
-}
-
-void checkEqual_VkImageResolve2KHR(const VkImageResolve2KHR* a, const VkImageResolve2KHR* b,
-                                   OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
+    if (!((a->producer) == (b->producer))) {
+        onFail("a->producer (Error: Value not equal)");
     };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    checkEqual_VkImageSubresourceLayers(&a->srcSubresource, &b->srcSubresource, onFail);
-    checkEqual_VkOffset3D(&a->srcOffset, &b->srcOffset, onFail);
-    checkEqual_VkImageSubresourceLayers(&a->dstSubresource, &b->dstSubresource, onFail);
-    checkEqual_VkOffset3D(&a->dstOffset, &b->dstOffset, onFail);
-    checkEqual_VkExtent3D(&a->extent, &b->extent, onFail);
 }
 
-void checkEqual_VkResolveImageInfo2KHR(const VkResolveImageInfo2KHR* a,
-                                       const VkResolveImageInfo2KHR* b, OnFailCompareFunc onFail) {
+void checkEqual_VkNativeBufferANDROID(const VkNativeBufferANDROID* a,
+                                      const VkNativeBufferANDROID* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->srcImage) == (b->srcImage))) {
-        onFail("a->srcImage (Error: Value not equal)");
-    };
-    if (!((a->srcImageLayout) == (b->srcImageLayout))) {
-        onFail("a->srcImageLayout (Error: Value not equal)");
-    };
-    if (!((a->dstImage) == (b->dstImage))) {
-        onFail("a->dstImage (Error: Value not equal)");
-    };
-    if (!((a->dstImageLayout) == (b->dstImageLayout))) {
-        onFail("a->dstImageLayout (Error: Value not equal)");
-    };
-    if (!((a->regionCount) == (b->regionCount))) {
-        onFail("a->regionCount (Error: Value not equal)");
+    if (!((!(a->handle) && !(b->handle)) || ((a->handle) && (b->handle)))) {
+        onFail("a->handle (Error: Mismatch in optional field)");
     };
-    if ((a->pRegions) && (b->pRegions)) {
-        if (!((a->regionCount) == (b->regionCount))) {
-            onFail("a->pRegions (Error: Lengths not equal)");
+    if (a->handle && b->handle) {
+        if (!((memcmp(a->handle, b->handle, sizeof(const uint32_t)) == 0))) {
+            onFail("a->handle (Error: Unequal dyn array)");
         };
-        if ((a->regionCount) == (b->regionCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->regionCount; ++i) {
-                    checkEqual_VkImageResolve2KHR(a->pRegions + i, b->pRegions + i, onFail);
-                }
-            }
-        }
-    }
-}
-
-#endif
-#ifdef VK_KHR_format_feature_flags2
-void checkEqual_VkFormatProperties3KHR(const VkFormatProperties3KHR* a,
-                                       const VkFormatProperties3KHR* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->linearTilingFeatures) == (b->linearTilingFeatures))) {
-        onFail("a->linearTilingFeatures (Error: Value not equal)");
-    };
-    if (!((a->optimalTilingFeatures) == (b->optimalTilingFeatures))) {
-        onFail("a->optimalTilingFeatures (Error: Value not equal)");
-    };
-    if (!((a->bufferFeatures) == (b->bufferFeatures))) {
-        onFail("a->bufferFeatures (Error: Value not equal)");
-    };
-}
-
-#endif
-#ifdef VK_KHR_maintenance4
-void checkEqual_VkPhysicalDeviceMaintenance4FeaturesKHR(
-    const VkPhysicalDeviceMaintenance4FeaturesKHR* a,
-    const VkPhysicalDeviceMaintenance4FeaturesKHR* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->maintenance4) == (b->maintenance4))) {
-        onFail("a->maintenance4 (Error: Value not equal)");
-    };
-}
-
-void checkEqual_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    const VkPhysicalDeviceMaintenance4PropertiesKHR* a,
-    const VkPhysicalDeviceMaintenance4PropertiesKHR* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
+    if (!((a->stride) == (b->stride))) {
+        onFail("a->stride (Error: Value not equal)");
     };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->maxBufferSize) == (b->maxBufferSize))) {
-        onFail("a->maxBufferSize (Error: Value not equal)");
+    if (!((a->format) == (b->format))) {
+        onFail("a->format (Error: Value not equal)");
     };
-}
-
-void checkEqual_VkDeviceBufferMemoryRequirementsKHR(const VkDeviceBufferMemoryRequirementsKHR* a,
-                                                    const VkDeviceBufferMemoryRequirementsKHR* b,
-                                                    OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
+    if (!((a->usage) == (b->usage))) {
+        onFail("a->usage (Error: Value not equal)");
     };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if ((a->pCreateInfo) && (b->pCreateInfo)) {
-        checkEqual_VkBufferCreateInfo(a->pCreateInfo, b->pCreateInfo, onFail);
-    }
+    checkEqual_VkNativeBufferUsage2ANDROID(&a->usage2, &b->usage2, onFail);
 }
 
-void checkEqual_VkDeviceImageMemoryRequirementsKHR(const VkDeviceImageMemoryRequirementsKHR* a,
-                                                   const VkDeviceImageMemoryRequirementsKHR* b,
-                                                   OnFailCompareFunc onFail) {
+void checkEqual_VkSwapchainImageCreateInfoANDROID(const VkSwapchainImageCreateInfoANDROID* a,
+                                                  const VkSwapchainImageCreateInfoANDROID* b,
+                                                  OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if ((a->pCreateInfo) && (b->pCreateInfo)) {
-        checkEqual_VkImageCreateInfo(a->pCreateInfo, b->pCreateInfo, onFail);
-    }
-    if (!((a->planeAspect) == (b->planeAspect))) {
-        onFail("a->planeAspect (Error: Value not equal)");
+    if (!((a->usage) == (b->usage))) {
+        onFail("a->usage (Error: Value not equal)");
     };
 }
 
-#endif
-#ifdef VK_ANDROID_native_buffer
-void checkEqual_VkNativeBufferANDROID(const VkNativeBufferANDROID* a,
-                                      const VkNativeBufferANDROID* b, OnFailCompareFunc onFail) {
+void checkEqual_VkPhysicalDevicePresentationPropertiesANDROID(
+    const VkPhysicalDevicePresentationPropertiesANDROID* a,
+    const VkPhysicalDevicePresentationPropertiesANDROID* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((!(a->handle) && !(b->handle)) || ((a->handle) && (b->handle)))) {
-        onFail("a->handle (Error: Mismatch in optional field)");
-    };
-    if (a->handle && b->handle) {
-        if (!((memcmp(a->handle, b->handle, sizeof(const uint32_t)) == 0))) {
-            onFail("a->handle (Error: Unequal dyn array)");
-        };
-    }
-    if (!((a->stride) == (b->stride))) {
-        onFail("a->stride (Error: Value not equal)");
-    };
-    if (!((a->format) == (b->format))) {
-        onFail("a->format (Error: Value not equal)");
-    };
-    if (!((a->usage) == (b->usage))) {
-        onFail("a->usage (Error: Value not equal)");
-    };
-    if (!((a->consumer) == (b->consumer))) {
-        onFail("a->consumer (Error: Value not equal)");
-    };
-    if (!((a->producer) == (b->producer))) {
-        onFail("a->producer (Error: Value not equal)");
+    if (!((a->sharedImage) == (b->sharedImage))) {
+        onFail("a->sharedImage (Error: Value not equal)");
     };
 }
 
@@ -10249,46 +11531,30 @@ void checkEqual_VkVideoEncodeH264CapabilitiesEXT(const VkVideoEncodeH264Capabili
     if (!((a->flags) == (b->flags))) {
         onFail("a->flags (Error: Value not equal)");
     };
-    if (!((a->inputModeFlags) == (b->inputModeFlags))) {
-        onFail("a->inputModeFlags (Error: Value not equal)");
+    if (!((a->maxPPictureL0ReferenceCount) == (b->maxPPictureL0ReferenceCount))) {
+        onFail("a->maxPPictureL0ReferenceCount (Error: Value not equal)");
     };
-    if (!((a->outputModeFlags) == (b->outputModeFlags))) {
-        onFail("a->outputModeFlags (Error: Value not equal)");
+    if (!((a->maxBPictureL0ReferenceCount) == (b->maxBPictureL0ReferenceCount))) {
+        onFail("a->maxBPictureL0ReferenceCount (Error: Value not equal)");
     };
-    checkEqual_VkExtent2D(&a->minPictureSizeInMbs, &b->minPictureSizeInMbs, onFail);
-    checkEqual_VkExtent2D(&a->maxPictureSizeInMbs, &b->maxPictureSizeInMbs, onFail);
-    checkEqual_VkExtent2D(&a->inputImageDataAlignment, &b->inputImageDataAlignment, onFail);
-    if (!((a->maxNumL0ReferenceForP) == (b->maxNumL0ReferenceForP))) {
-        onFail("a->maxNumL0ReferenceForP (Error: Value not equal)");
+    if (!((a->maxL1ReferenceCount) == (b->maxL1ReferenceCount))) {
+        onFail("a->maxL1ReferenceCount (Error: Value not equal)");
     };
-    if (!((a->maxNumL0ReferenceForB) == (b->maxNumL0ReferenceForB))) {
-        onFail("a->maxNumL0ReferenceForB (Error: Value not equal)");
+    if (!((a->motionVectorsOverPicBoundariesFlag) == (b->motionVectorsOverPicBoundariesFlag))) {
+        onFail("a->motionVectorsOverPicBoundariesFlag (Error: Value not equal)");
     };
-    if (!((a->maxNumL1Reference) == (b->maxNumL1Reference))) {
-        onFail("a->maxNumL1Reference (Error: Value not equal)");
+    if (!((a->maxBytesPerPicDenom) == (b->maxBytesPerPicDenom))) {
+        onFail("a->maxBytesPerPicDenom (Error: Value not equal)");
     };
-    if (!((a->qualityLevelCount) == (b->qualityLevelCount))) {
-        onFail("a->qualityLevelCount (Error: Value not equal)");
+    if (!((a->maxBitsPerMbDenom) == (b->maxBitsPerMbDenom))) {
+        onFail("a->maxBitsPerMbDenom (Error: Value not equal)");
     };
-    checkEqual_VkExtensionProperties(&a->stdExtensionVersion, &b->stdExtensionVersion, onFail);
-}
-
-void checkEqual_VkVideoEncodeH264SessionCreateInfoEXT(
-    const VkVideoEncodeH264SessionCreateInfoEXT* a, const VkVideoEncodeH264SessionCreateInfoEXT* b,
-    OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
+    if (!((a->log2MaxMvLengthHorizontal) == (b->log2MaxMvLengthHorizontal))) {
+        onFail("a->log2MaxMvLengthHorizontal (Error: Value not equal)");
     };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->flags) == (b->flags))) {
-        onFail("a->flags (Error: Value not equal)");
+    if (!((a->log2MaxMvLengthVertical) == (b->log2MaxMvLengthVertical))) {
+        onFail("a->log2MaxMvLengthVertical (Error: Value not equal)");
     };
-    checkEqual_VkExtent2D(&a->maxPictureSizeInMbs, &b->maxPictureSizeInMbs, onFail);
-    if ((a->pStdExtensionVersion) && (b->pStdExtensionVersion)) {
-        checkEqual_VkExtensionProperties(a->pStdExtensionVersion, b->pStdExtensionVersion, onFail);
-    }
 }
 
 void checkEqual_VkVideoEncodeH264SessionParametersAddInfoEXT(
@@ -10300,34 +11566,34 @@ void checkEqual_VkVideoEncodeH264SessionParametersAddInfoEXT(
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->spsStdCount) == (b->spsStdCount))) {
-        onFail("a->spsStdCount (Error: Value not equal)");
+    if (!((a->stdSPSCount) == (b->stdSPSCount))) {
+        onFail("a->stdSPSCount (Error: Value not equal)");
     };
-    if (!((!(a->pSpsStd) && !(b->pSpsStd)) || ((a->pSpsStd) && (b->pSpsStd)))) {
-        onFail("a->pSpsStd (Error: Mismatch in optional field)");
+    if (!((!(a->pStdSPSs) && !(b->pStdSPSs)) || ((a->pStdSPSs) && (b->pStdSPSs)))) {
+        onFail("a->pStdSPSs (Error: Mismatch in optional field)");
     };
-    if (a->pSpsStd && b->pSpsStd) {
-        if (!((a->spsStdCount) == (b->spsStdCount))) {
-            onFail("a->pSpsStd (Error: Lengths not equal)");
+    if (a->pStdSPSs && b->pStdSPSs) {
+        if (!((a->stdSPSCount) == (b->stdSPSCount))) {
+            onFail("a->pStdSPSs (Error: Lengths not equal)");
         };
-        if (!((memcmp(a->pSpsStd, b->pSpsStd,
-                      a->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet)) == 0))) {
-            onFail("a->pSpsStd (Error: Unequal dyn array)");
+        if (!((memcmp(a->pStdSPSs, b->pStdSPSs,
+                      a->stdSPSCount * sizeof(const StdVideoH264SequenceParameterSet)) == 0))) {
+            onFail("a->pStdSPSs (Error: Unequal dyn array)");
         };
     }
-    if (!((a->ppsStdCount) == (b->ppsStdCount))) {
-        onFail("a->ppsStdCount (Error: Value not equal)");
+    if (!((a->stdPPSCount) == (b->stdPPSCount))) {
+        onFail("a->stdPPSCount (Error: Value not equal)");
     };
-    if (!((!(a->pPpsStd) && !(b->pPpsStd)) || ((a->pPpsStd) && (b->pPpsStd)))) {
-        onFail("a->pPpsStd (Error: Mismatch in optional field)");
+    if (!((!(a->pStdPPSs) && !(b->pStdPPSs)) || ((a->pStdPPSs) && (b->pStdPPSs)))) {
+        onFail("a->pStdPPSs (Error: Mismatch in optional field)");
     };
-    if (a->pPpsStd && b->pPpsStd) {
-        if (!((a->ppsStdCount) == (b->ppsStdCount))) {
-            onFail("a->pPpsStd (Error: Lengths not equal)");
+    if (a->pStdPPSs && b->pStdPPSs) {
+        if (!((a->stdPPSCount) == (b->stdPPSCount))) {
+            onFail("a->pStdPPSs (Error: Lengths not equal)");
         };
-        if (!((memcmp(a->pPpsStd, b->pPpsStd,
-                      a->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet)) == 0))) {
-            onFail("a->pPpsStd (Error: Unequal dyn array)");
+        if (!((memcmp(a->pStdPPSs, b->pStdPPSs,
+                      a->stdPPSCount * sizeof(const StdVideoH264PictureParameterSet)) == 0))) {
+            onFail("a->pStdPPSs (Error: Unequal dyn array)");
         };
     }
 }
@@ -10341,11 +11607,11 @@ void checkEqual_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->maxSpsStdCount) == (b->maxSpsStdCount))) {
-        onFail("a->maxSpsStdCount (Error: Value not equal)");
+    if (!((a->maxStdSPSCount) == (b->maxStdSPSCount))) {
+        onFail("a->maxStdSPSCount (Error: Value not equal)");
     };
-    if (!((a->maxPpsStdCount) == (b->maxPpsStdCount))) {
-        onFail("a->maxPpsStdCount (Error: Value not equal)");
+    if (!((a->maxStdPPSCount) == (b->maxStdPPSCount))) {
+        onFail("a->maxStdPPSCount (Error: Value not equal)");
     };
     if (!((!(a->pParametersAddInfo) && !(b->pParametersAddInfo)) ||
           ((a->pParametersAddInfo) && (b->pParametersAddInfo)))) {
@@ -10359,80 +11625,31 @@ void checkEqual_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     }
 }
 
-void checkEqual_VkVideoEncodeH264DpbSlotInfoEXT(const VkVideoEncodeH264DpbSlotInfoEXT* a,
-                                                const VkVideoEncodeH264DpbSlotInfoEXT* b,
-                                                OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->slotIndex) == (b->slotIndex))) {
-        onFail("a->slotIndex (Error: Value not equal)");
-    };
-    if (!((memcmp(a->pStdPictureInfo, b->pStdPictureInfo,
-                  sizeof(const StdVideoEncodeH264PictureInfo)) == 0))) {
-        onFail("a->pStdPictureInfo (Error: Unequal dyn array)");
-    };
-}
-
-void checkEqual_VkVideoEncodeH264NaluSliceEXT(const VkVideoEncodeH264NaluSliceEXT* a,
-                                              const VkVideoEncodeH264NaluSliceEXT* b,
-                                              OnFailCompareFunc onFail) {
+void checkEqual_VkVideoEncodeH264NaluSliceInfoEXT(const VkVideoEncodeH264NaluSliceInfoEXT* a,
+                                                  const VkVideoEncodeH264NaluSliceInfoEXT* b,
+                                                  OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((memcmp(a->pSliceHeaderStd, b->pSliceHeaderStd,
-                  sizeof(const StdVideoEncodeH264SliceHeader)) == 0))) {
-        onFail("a->pSliceHeaderStd (Error: Unequal dyn array)");
-    };
     if (!((a->mbCount) == (b->mbCount))) {
         onFail("a->mbCount (Error: Value not equal)");
     };
-    if (!((a->refFinalList0EntryCount) == (b->refFinalList0EntryCount))) {
-        onFail("a->refFinalList0EntryCount (Error: Value not equal)");
-    };
-    if ((a->pRefFinalList0Entries) && (b->pRefFinalList0Entries)) {
-        if (!((a->refFinalList0EntryCount) == (b->refFinalList0EntryCount))) {
-            onFail("a->pRefFinalList0Entries (Error: Lengths not equal)");
-        };
-        if ((a->refFinalList0EntryCount) == (b->refFinalList0EntryCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->refFinalList0EntryCount; ++i) {
-                    checkEqual_VkVideoEncodeH264DpbSlotInfoEXT(
-                        a->pRefFinalList0Entries + i, b->pRefFinalList0Entries + i, onFail);
-                }
-            }
-        }
-    }
-    if (!((a->refFinalList1EntryCount) == (b->refFinalList1EntryCount))) {
-        onFail("a->refFinalList1EntryCount (Error: Value not equal)");
+    if (!((!(a->pStdReferenceFinalLists) && !(b->pStdReferenceFinalLists)) ||
+          ((a->pStdReferenceFinalLists) && (b->pStdReferenceFinalLists)))) {
+        onFail("a->pStdReferenceFinalLists (Error: Mismatch in optional field)");
     };
-    if ((a->pRefFinalList1Entries) && (b->pRefFinalList1Entries)) {
-        if (!((a->refFinalList1EntryCount) == (b->refFinalList1EntryCount))) {
-            onFail("a->pRefFinalList1Entries (Error: Lengths not equal)");
+    if (a->pStdReferenceFinalLists && b->pStdReferenceFinalLists) {
+        if (!((memcmp(a->pStdReferenceFinalLists, b->pStdReferenceFinalLists,
+                      sizeof(const StdVideoEncodeH264ReferenceListsInfo)) == 0))) {
+            onFail("a->pStdReferenceFinalLists (Error: Unequal dyn array)");
         };
-        if ((a->refFinalList1EntryCount) == (b->refFinalList1EntryCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->refFinalList1EntryCount; ++i) {
-                    checkEqual_VkVideoEncodeH264DpbSlotInfoEXT(
-                        a->pRefFinalList1Entries + i, b->pRefFinalList1Entries + i, onFail);
-                }
-            }
-        }
     }
-    if (!((a->precedingNaluBytes) == (b->precedingNaluBytes))) {
-        onFail("a->precedingNaluBytes (Error: Value not equal)");
-    };
-    if (!((a->minQp) == (b->minQp))) {
-        onFail("a->minQp (Error: Value not equal)");
-    };
-    if (!((a->maxQp) == (b->maxQp))) {
-        onFail("a->maxQp (Error: Value not equal)");
+    if (!((memcmp(a->pStdSliceHeader, b->pStdSliceHeader,
+                  sizeof(const StdVideoEncodeH264SliceHeader)) == 0))) {
+        onFail("a->pStdSliceHeader (Error: Unequal dyn array)");
     };
 }
 
@@ -10445,39 +11662,15 @@ void checkEqual_VkVideoEncodeH264VclFrameInfoEXT(const VkVideoEncodeH264VclFrame
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->refDefaultFinalList0EntryCount) == (b->refDefaultFinalList0EntryCount))) {
-        onFail("a->refDefaultFinalList0EntryCount (Error: Value not equal)");
-    };
-    if ((a->pRefDefaultFinalList0Entries) && (b->pRefDefaultFinalList0Entries)) {
-        if (!((a->refDefaultFinalList0EntryCount) == (b->refDefaultFinalList0EntryCount))) {
-            onFail("a->pRefDefaultFinalList0Entries (Error: Lengths not equal)");
-        };
-        if ((a->refDefaultFinalList0EntryCount) == (b->refDefaultFinalList0EntryCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->refDefaultFinalList0EntryCount; ++i) {
-                    checkEqual_VkVideoEncodeH264DpbSlotInfoEXT(a->pRefDefaultFinalList0Entries + i,
-                                                               b->pRefDefaultFinalList0Entries + i,
-                                                               onFail);
-                }
-            }
-        }
-    }
-    if (!((a->refDefaultFinalList1EntryCount) == (b->refDefaultFinalList1EntryCount))) {
-        onFail("a->refDefaultFinalList1EntryCount (Error: Value not equal)");
+    if (!((!(a->pStdReferenceFinalLists) && !(b->pStdReferenceFinalLists)) ||
+          ((a->pStdReferenceFinalLists) && (b->pStdReferenceFinalLists)))) {
+        onFail("a->pStdReferenceFinalLists (Error: Mismatch in optional field)");
     };
-    if ((a->pRefDefaultFinalList1Entries) && (b->pRefDefaultFinalList1Entries)) {
-        if (!((a->refDefaultFinalList1EntryCount) == (b->refDefaultFinalList1EntryCount))) {
-            onFail("a->pRefDefaultFinalList1Entries (Error: Lengths not equal)");
+    if (a->pStdReferenceFinalLists && b->pStdReferenceFinalLists) {
+        if (!((memcmp(a->pStdReferenceFinalLists, b->pStdReferenceFinalLists,
+                      sizeof(const StdVideoEncodeH264ReferenceListsInfo)) == 0))) {
+            onFail("a->pStdReferenceFinalLists (Error: Unequal dyn array)");
         };
-        if ((a->refDefaultFinalList1EntryCount) == (b->refDefaultFinalList1EntryCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->refDefaultFinalList1EntryCount; ++i) {
-                    checkEqual_VkVideoEncodeH264DpbSlotInfoEXT(a->pRefDefaultFinalList1Entries + i,
-                                                               b->pRefDefaultFinalList1Entries + i,
-                                                               onFail);
-                }
-            }
-        }
     }
     if (!((a->naluSliceEntryCount) == (b->naluSliceEntryCount))) {
         onFail("a->naluSliceEntryCount (Error: Value not equal)");
@@ -10489,57 +11682,128 @@ void checkEqual_VkVideoEncodeH264VclFrameInfoEXT(const VkVideoEncodeH264VclFrame
         if ((a->naluSliceEntryCount) == (b->naluSliceEntryCount)) {
             if (a) {
                 for (uint32_t i = 0; i < (uint32_t)a->naluSliceEntryCount; ++i) {
-                    checkEqual_VkVideoEncodeH264NaluSliceEXT(a->pNaluSliceEntries + i,
-                                                             b->pNaluSliceEntries + i, onFail);
+                    checkEqual_VkVideoEncodeH264NaluSliceInfoEXT(a->pNaluSliceEntries + i,
+                                                                 b->pNaluSliceEntries + i, onFail);
                 }
             }
         }
     }
-    if ((a->pCurrentPictureInfo) && (b->pCurrentPictureInfo)) {
-        checkEqual_VkVideoEncodeH264DpbSlotInfoEXT(a->pCurrentPictureInfo, b->pCurrentPictureInfo,
-                                                   onFail);
+    if (!((memcmp(a->pStdPictureInfo, b->pStdPictureInfo,
+                  sizeof(const StdVideoEncodeH264PictureInfo)) == 0))) {
+        onFail("a->pStdPictureInfo (Error: Unequal dyn array)");
+    };
+}
+
+void checkEqual_VkVideoEncodeH264DpbSlotInfoEXT(const VkVideoEncodeH264DpbSlotInfoEXT* a,
+                                                const VkVideoEncodeH264DpbSlotInfoEXT* b,
+                                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((memcmp(a->pStdReferenceInfo, b->pStdReferenceInfo,
+                  sizeof(const StdVideoEncodeH264ReferenceInfo)) == 0))) {
+        onFail("a->pStdReferenceInfo (Error: Unequal dyn array)");
+    };
+}
+
+void checkEqual_VkVideoEncodeH264ProfileInfoEXT(const VkVideoEncodeH264ProfileInfoEXT* a,
+                                                const VkVideoEncodeH264ProfileInfoEXT* b,
+                                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
+    if (!((a->stdProfileIdc) == (b->stdProfileIdc))) {
+        onFail("a->stdProfileIdc (Error: Value not equal)");
+    };
 }
 
-void checkEqual_VkVideoEncodeH264EmitPictureParametersEXT(
-    const VkVideoEncodeH264EmitPictureParametersEXT* a,
-    const VkVideoEncodeH264EmitPictureParametersEXT* b, OnFailCompareFunc onFail) {
+void checkEqual_VkVideoEncodeH264RateControlInfoEXT(const VkVideoEncodeH264RateControlInfoEXT* a,
+                                                    const VkVideoEncodeH264RateControlInfoEXT* b,
+                                                    OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->spsId) == (b->spsId))) {
-        onFail("a->spsId (Error: Value not equal)");
+    if (!((a->gopFrameCount) == (b->gopFrameCount))) {
+        onFail("a->gopFrameCount (Error: Value not equal)");
     };
-    if (!((a->emitSpsEnable) == (b->emitSpsEnable))) {
-        onFail("a->emitSpsEnable (Error: Value not equal)");
+    if (!((a->idrPeriod) == (b->idrPeriod))) {
+        onFail("a->idrPeriod (Error: Value not equal)");
     };
-    if (!((a->ppsIdEntryCount) == (b->ppsIdEntryCount))) {
-        onFail("a->ppsIdEntryCount (Error: Value not equal)");
+    if (!((a->consecutiveBFrameCount) == (b->consecutiveBFrameCount))) {
+        onFail("a->consecutiveBFrameCount (Error: Value not equal)");
     };
-    if (!((a->ppsIdEntryCount) == (b->ppsIdEntryCount))) {
-        onFail("a->ppsIdEntries (Error: Lengths not equal)");
+    if (!((a->rateControlStructure) == (b->rateControlStructure))) {
+        onFail("a->rateControlStructure (Error: Value not equal)");
     };
-    if (!((memcmp(a->ppsIdEntries, b->ppsIdEntries, a->ppsIdEntryCount * sizeof(const uint8_t)) ==
-           0))) {
-        onFail("a->ppsIdEntries (Error: Unequal dyn array)");
+    if (!((a->temporalLayerCount) == (b->temporalLayerCount))) {
+        onFail("a->temporalLayerCount (Error: Value not equal)");
     };
 }
 
-void checkEqual_VkVideoEncodeH264ProfileEXT(const VkVideoEncodeH264ProfileEXT* a,
-                                            const VkVideoEncodeH264ProfileEXT* b,
-                                            OnFailCompareFunc onFail) {
+void checkEqual_VkVideoEncodeH264QpEXT(const VkVideoEncodeH264QpEXT* a,
+                                       const VkVideoEncodeH264QpEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->qpI) == (b->qpI))) {
+        onFail("a->qpI (Error: Value not equal)");
+    };
+    if (!((a->qpP) == (b->qpP))) {
+        onFail("a->qpP (Error: Value not equal)");
+    };
+    if (!((a->qpB) == (b->qpB))) {
+        onFail("a->qpB (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkVideoEncodeH264FrameSizeEXT(const VkVideoEncodeH264FrameSizeEXT* a,
+                                              const VkVideoEncodeH264FrameSizeEXT* b,
+                                              OnFailCompareFunc onFail) {
+    if (!((a->frameISize) == (b->frameISize))) {
+        onFail("a->frameISize (Error: Value not equal)");
+    };
+    if (!((a->framePSize) == (b->framePSize))) {
+        onFail("a->framePSize (Error: Value not equal)");
+    };
+    if (!((a->frameBSize) == (b->frameBSize))) {
+        onFail("a->frameBSize (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkVideoEncodeH264RateControlLayerInfoEXT(
+    const VkVideoEncodeH264RateControlLayerInfoEXT* a,
+    const VkVideoEncodeH264RateControlLayerInfoEXT* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->stdProfileIdc) == (b->stdProfileIdc))) {
-        onFail("a->stdProfileIdc (Error: Value not equal)");
+    if (!((a->temporalLayerId) == (b->temporalLayerId))) {
+        onFail("a->temporalLayerId (Error: Value not equal)");
+    };
+    if (!((a->useInitialRcQp) == (b->useInitialRcQp))) {
+        onFail("a->useInitialRcQp (Error: Value not equal)");
     };
+    checkEqual_VkVideoEncodeH264QpEXT(&a->initialRcQp, &b->initialRcQp, onFail);
+    if (!((a->useMinQp) == (b->useMinQp))) {
+        onFail("a->useMinQp (Error: Value not equal)");
+    };
+    checkEqual_VkVideoEncodeH264QpEXT(&a->minQp, &b->minQp, onFail);
+    if (!((a->useMaxQp) == (b->useMaxQp))) {
+        onFail("a->useMaxQp (Error: Value not equal)");
+    };
+    checkEqual_VkVideoEncodeH264QpEXT(&a->maxQp, &b->maxQp, onFail);
+    if (!((a->useMaxFrameSize) == (b->useMaxFrameSize))) {
+        onFail("a->useMaxFrameSize (Error: Value not equal)");
+    };
+    checkEqual_VkVideoEncodeH264FrameSizeEXT(&a->maxFrameSize, &b->maxFrameSize, onFail);
 }
 
 #endif
@@ -10556,49 +11820,59 @@ void checkEqual_VkVideoEncodeH265CapabilitiesEXT(const VkVideoEncodeH265Capabili
     if (!((a->flags) == (b->flags))) {
         onFail("a->flags (Error: Value not equal)");
     };
-    if (!((a->inputModeFlags) == (b->inputModeFlags))) {
-        onFail("a->inputModeFlags (Error: Value not equal)");
-    };
-    if (!((a->outputModeFlags) == (b->outputModeFlags))) {
-        onFail("a->outputModeFlags (Error: Value not equal)");
-    };
     if (!((a->ctbSizes) == (b->ctbSizes))) {
         onFail("a->ctbSizes (Error: Value not equal)");
     };
-    checkEqual_VkExtent2D(&a->inputImageDataAlignment, &b->inputImageDataAlignment, onFail);
-    if (!((a->maxNumL0ReferenceForP) == (b->maxNumL0ReferenceForP))) {
-        onFail("a->maxNumL0ReferenceForP (Error: Value not equal)");
+    if (!((a->transformBlockSizes) == (b->transformBlockSizes))) {
+        onFail("a->transformBlockSizes (Error: Value not equal)");
     };
-    if (!((a->maxNumL0ReferenceForB) == (b->maxNumL0ReferenceForB))) {
-        onFail("a->maxNumL0ReferenceForB (Error: Value not equal)");
+    if (!((a->maxPPictureL0ReferenceCount) == (b->maxPPictureL0ReferenceCount))) {
+        onFail("a->maxPPictureL0ReferenceCount (Error: Value not equal)");
     };
-    if (!((a->maxNumL1Reference) == (b->maxNumL1Reference))) {
-        onFail("a->maxNumL1Reference (Error: Value not equal)");
+    if (!((a->maxBPictureL0ReferenceCount) == (b->maxBPictureL0ReferenceCount))) {
+        onFail("a->maxBPictureL0ReferenceCount (Error: Value not equal)");
     };
-    if (!((a->maxNumSubLayers) == (b->maxNumSubLayers))) {
-        onFail("a->maxNumSubLayers (Error: Value not equal)");
+    if (!((a->maxL1ReferenceCount) == (b->maxL1ReferenceCount))) {
+        onFail("a->maxL1ReferenceCount (Error: Value not equal)");
     };
-    if (!((a->qualityLevelCount) == (b->qualityLevelCount))) {
-        onFail("a->qualityLevelCount (Error: Value not equal)");
+    if (!((a->maxSubLayersCount) == (b->maxSubLayersCount))) {
+        onFail("a->maxSubLayersCount (Error: Value not equal)");
     };
-    checkEqual_VkExtensionProperties(&a->stdExtensionVersion, &b->stdExtensionVersion, onFail);
-}
-
-void checkEqual_VkVideoEncodeH265SessionCreateInfoEXT(
-    const VkVideoEncodeH265SessionCreateInfoEXT* a, const VkVideoEncodeH265SessionCreateInfoEXT* b,
-    OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
+    if (!((a->minLog2MinLumaCodingBlockSizeMinus3) == (b->minLog2MinLumaCodingBlockSizeMinus3))) {
+        onFail("a->minLog2MinLumaCodingBlockSizeMinus3 (Error: Value not equal)");
     };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->flags) == (b->flags))) {
-        onFail("a->flags (Error: Value not equal)");
+    if (!((a->maxLog2MinLumaCodingBlockSizeMinus3) == (b->maxLog2MinLumaCodingBlockSizeMinus3))) {
+        onFail("a->maxLog2MinLumaCodingBlockSizeMinus3 (Error: Value not equal)");
+    };
+    if (!((a->minLog2MinLumaTransformBlockSizeMinus2) ==
+          (b->minLog2MinLumaTransformBlockSizeMinus2))) {
+        onFail("a->minLog2MinLumaTransformBlockSizeMinus2 (Error: Value not equal)");
+    };
+    if (!((a->maxLog2MinLumaTransformBlockSizeMinus2) ==
+          (b->maxLog2MinLumaTransformBlockSizeMinus2))) {
+        onFail("a->maxLog2MinLumaTransformBlockSizeMinus2 (Error: Value not equal)");
+    };
+    if (!((a->minMaxTransformHierarchyDepthInter) == (b->minMaxTransformHierarchyDepthInter))) {
+        onFail("a->minMaxTransformHierarchyDepthInter (Error: Value not equal)");
+    };
+    if (!((a->maxMaxTransformHierarchyDepthInter) == (b->maxMaxTransformHierarchyDepthInter))) {
+        onFail("a->maxMaxTransformHierarchyDepthInter (Error: Value not equal)");
+    };
+    if (!((a->minMaxTransformHierarchyDepthIntra) == (b->minMaxTransformHierarchyDepthIntra))) {
+        onFail("a->minMaxTransformHierarchyDepthIntra (Error: Value not equal)");
+    };
+    if (!((a->maxMaxTransformHierarchyDepthIntra) == (b->maxMaxTransformHierarchyDepthIntra))) {
+        onFail("a->maxMaxTransformHierarchyDepthIntra (Error: Value not equal)");
+    };
+    if (!((a->maxDiffCuQpDeltaDepth) == (b->maxDiffCuQpDeltaDepth))) {
+        onFail("a->maxDiffCuQpDeltaDepth (Error: Value not equal)");
+    };
+    if (!((a->minMaxNumMergeCand) == (b->minMaxNumMergeCand))) {
+        onFail("a->minMaxNumMergeCand (Error: Value not equal)");
+    };
+    if (!((a->maxMaxNumMergeCand) == (b->maxMaxNumMergeCand))) {
+        onFail("a->maxMaxNumMergeCand (Error: Value not equal)");
     };
-    if ((a->pStdExtensionVersion) && (b->pStdExtensionVersion)) {
-        checkEqual_VkExtensionProperties(a->pStdExtensionVersion, b->pStdExtensionVersion, onFail);
-    }
 }
 
 void checkEqual_VkVideoEncodeH265SessionParametersAddInfoEXT(
@@ -10610,49 +11884,49 @@ void checkEqual_VkVideoEncodeH265SessionParametersAddInfoEXT(
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->vpsStdCount) == (b->vpsStdCount))) {
-        onFail("a->vpsStdCount (Error: Value not equal)");
+    if (!((a->stdVPSCount) == (b->stdVPSCount))) {
+        onFail("a->stdVPSCount (Error: Value not equal)");
     };
-    if (!((!(a->pVpsStd) && !(b->pVpsStd)) || ((a->pVpsStd) && (b->pVpsStd)))) {
-        onFail("a->pVpsStd (Error: Mismatch in optional field)");
+    if (!((!(a->pStdVPSs) && !(b->pStdVPSs)) || ((a->pStdVPSs) && (b->pStdVPSs)))) {
+        onFail("a->pStdVPSs (Error: Mismatch in optional field)");
     };
-    if (a->pVpsStd && b->pVpsStd) {
-        if (!((a->vpsStdCount) == (b->vpsStdCount))) {
-            onFail("a->pVpsStd (Error: Lengths not equal)");
+    if (a->pStdVPSs && b->pStdVPSs) {
+        if (!((a->stdVPSCount) == (b->stdVPSCount))) {
+            onFail("a->pStdVPSs (Error: Lengths not equal)");
         };
-        if (!((memcmp(a->pVpsStd, b->pVpsStd,
-                      a->vpsStdCount * sizeof(const StdVideoH265VideoParameterSet)) == 0))) {
-            onFail("a->pVpsStd (Error: Unequal dyn array)");
+        if (!((memcmp(a->pStdVPSs, b->pStdVPSs,
+                      a->stdVPSCount * sizeof(const StdVideoH265VideoParameterSet)) == 0))) {
+            onFail("a->pStdVPSs (Error: Unequal dyn array)");
         };
     }
-    if (!((a->spsStdCount) == (b->spsStdCount))) {
-        onFail("a->spsStdCount (Error: Value not equal)");
+    if (!((a->stdSPSCount) == (b->stdSPSCount))) {
+        onFail("a->stdSPSCount (Error: Value not equal)");
     };
-    if (!((!(a->pSpsStd) && !(b->pSpsStd)) || ((a->pSpsStd) && (b->pSpsStd)))) {
-        onFail("a->pSpsStd (Error: Mismatch in optional field)");
+    if (!((!(a->pStdSPSs) && !(b->pStdSPSs)) || ((a->pStdSPSs) && (b->pStdSPSs)))) {
+        onFail("a->pStdSPSs (Error: Mismatch in optional field)");
     };
-    if (a->pSpsStd && b->pSpsStd) {
-        if (!((a->spsStdCount) == (b->spsStdCount))) {
-            onFail("a->pSpsStd (Error: Lengths not equal)");
+    if (a->pStdSPSs && b->pStdSPSs) {
+        if (!((a->stdSPSCount) == (b->stdSPSCount))) {
+            onFail("a->pStdSPSs (Error: Lengths not equal)");
         };
-        if (!((memcmp(a->pSpsStd, b->pSpsStd,
-                      a->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet)) == 0))) {
-            onFail("a->pSpsStd (Error: Unequal dyn array)");
+        if (!((memcmp(a->pStdSPSs, b->pStdSPSs,
+                      a->stdSPSCount * sizeof(const StdVideoH265SequenceParameterSet)) == 0))) {
+            onFail("a->pStdSPSs (Error: Unequal dyn array)");
         };
     }
-    if (!((a->ppsStdCount) == (b->ppsStdCount))) {
-        onFail("a->ppsStdCount (Error: Value not equal)");
+    if (!((a->stdPPSCount) == (b->stdPPSCount))) {
+        onFail("a->stdPPSCount (Error: Value not equal)");
     };
-    if (!((!(a->pPpsStd) && !(b->pPpsStd)) || ((a->pPpsStd) && (b->pPpsStd)))) {
-        onFail("a->pPpsStd (Error: Mismatch in optional field)");
+    if (!((!(a->pStdPPSs) && !(b->pStdPPSs)) || ((a->pStdPPSs) && (b->pStdPPSs)))) {
+        onFail("a->pStdPPSs (Error: Mismatch in optional field)");
     };
-    if (a->pPpsStd && b->pPpsStd) {
-        if (!((a->ppsStdCount) == (b->ppsStdCount))) {
-            onFail("a->pPpsStd (Error: Lengths not equal)");
+    if (a->pStdPPSs && b->pStdPPSs) {
+        if (!((a->stdPPSCount) == (b->stdPPSCount))) {
+            onFail("a->pStdPPSs (Error: Lengths not equal)");
         };
-        if (!((memcmp(a->pPpsStd, b->pPpsStd,
-                      a->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet)) == 0))) {
-            onFail("a->pPpsStd (Error: Unequal dyn array)");
+        if (!((memcmp(a->pStdPPSs, b->pStdPPSs,
+                      a->stdPPSCount * sizeof(const StdVideoH265PictureParameterSet)) == 0))) {
+            onFail("a->pStdPPSs (Error: Unequal dyn array)");
         };
     }
 }
@@ -10666,14 +11940,14 @@ void checkEqual_VkVideoEncodeH265SessionParametersCreateInfoEXT(
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->maxVpsStdCount) == (b->maxVpsStdCount))) {
-        onFail("a->maxVpsStdCount (Error: Value not equal)");
+    if (!((a->maxStdVPSCount) == (b->maxStdVPSCount))) {
+        onFail("a->maxStdVPSCount (Error: Value not equal)");
     };
-    if (!((a->maxSpsStdCount) == (b->maxSpsStdCount))) {
-        onFail("a->maxSpsStdCount (Error: Value not equal)");
+    if (!((a->maxStdSPSCount) == (b->maxStdSPSCount))) {
+        onFail("a->maxStdSPSCount (Error: Value not equal)");
     };
-    if (!((a->maxPpsStdCount) == (b->maxPpsStdCount))) {
-        onFail("a->maxPpsStdCount (Error: Value not equal)");
+    if (!((a->maxStdPPSCount) == (b->maxStdPPSCount))) {
+        onFail("a->maxStdPPSCount (Error: Value not equal)");
     };
     if (!((!(a->pParametersAddInfo) && !(b->pParametersAddInfo)) ||
           ((a->pParametersAddInfo) && (b->pParametersAddInfo)))) {
@@ -10687,74 +11961,9 @@ void checkEqual_VkVideoEncodeH265SessionParametersCreateInfoEXT(
     }
 }
 
-void checkEqual_VkVideoEncodeH265DpbSlotInfoEXT(const VkVideoEncodeH265DpbSlotInfoEXT* a,
-                                                const VkVideoEncodeH265DpbSlotInfoEXT* b,
-                                                OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->slotIndex) == (b->slotIndex))) {
-        onFail("a->slotIndex (Error: Value not equal)");
-    };
-    if (!((memcmp(a->pStdReferenceInfo, b->pStdReferenceInfo,
-                  sizeof(const StdVideoEncodeH265ReferenceInfo)) == 0))) {
-        onFail("a->pStdReferenceInfo (Error: Unequal dyn array)");
-    };
-}
-
-void checkEqual_VkVideoEncodeH265ReferenceListsEXT(const VkVideoEncodeH265ReferenceListsEXT* a,
-                                                   const VkVideoEncodeH265ReferenceListsEXT* b,
-                                                   OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->referenceList0EntryCount) == (b->referenceList0EntryCount))) {
-        onFail("a->referenceList0EntryCount (Error: Value not equal)");
-    };
-    if ((a->pReferenceList0Entries) && (b->pReferenceList0Entries)) {
-        if (!((a->referenceList0EntryCount) == (b->referenceList0EntryCount))) {
-            onFail("a->pReferenceList0Entries (Error: Lengths not equal)");
-        };
-        if ((a->referenceList0EntryCount) == (b->referenceList0EntryCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->referenceList0EntryCount; ++i) {
-                    checkEqual_VkVideoEncodeH265DpbSlotInfoEXT(
-                        a->pReferenceList0Entries + i, b->pReferenceList0Entries + i, onFail);
-                }
-            }
-        }
-    }
-    if (!((a->referenceList1EntryCount) == (b->referenceList1EntryCount))) {
-        onFail("a->referenceList1EntryCount (Error: Value not equal)");
-    };
-    if ((a->pReferenceList1Entries) && (b->pReferenceList1Entries)) {
-        if (!((a->referenceList1EntryCount) == (b->referenceList1EntryCount))) {
-            onFail("a->pReferenceList1Entries (Error: Lengths not equal)");
-        };
-        if ((a->referenceList1EntryCount) == (b->referenceList1EntryCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->referenceList1EntryCount; ++i) {
-                    checkEqual_VkVideoEncodeH265DpbSlotInfoEXT(
-                        a->pReferenceList1Entries + i, b->pReferenceList1Entries + i, onFail);
-                }
-            }
-        }
-    }
-    if (!((memcmp(a->pReferenceModifications, b->pReferenceModifications,
-                  sizeof(const StdVideoEncodeH265ReferenceModifications)) == 0))) {
-        onFail("a->pReferenceModifications (Error: Unequal dyn array)");
-    };
-}
-
-void checkEqual_VkVideoEncodeH265NaluSliceEXT(const VkVideoEncodeH265NaluSliceEXT* a,
-                                              const VkVideoEncodeH265NaluSliceEXT* b,
-                                              OnFailCompareFunc onFail) {
+void checkEqual_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+    const VkVideoEncodeH265NaluSliceSegmentInfoEXT* a,
+    const VkVideoEncodeH265NaluSliceSegmentInfoEXT* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
@@ -10764,19 +11973,19 @@ void checkEqual_VkVideoEncodeH265NaluSliceEXT(const VkVideoEncodeH265NaluSliceEX
     if (!((a->ctbCount) == (b->ctbCount))) {
         onFail("a->ctbCount (Error: Value not equal)");
     };
-    if (!((!(a->pReferenceFinalLists) && !(b->pReferenceFinalLists)) ||
-          ((a->pReferenceFinalLists) && (b->pReferenceFinalLists)))) {
-        onFail("a->pReferenceFinalLists (Error: Mismatch in optional field)");
+    if (!((!(a->pStdReferenceFinalLists) && !(b->pStdReferenceFinalLists)) ||
+          ((a->pStdReferenceFinalLists) && (b->pStdReferenceFinalLists)))) {
+        onFail("a->pStdReferenceFinalLists (Error: Mismatch in optional field)");
     };
-    if (a->pReferenceFinalLists && b->pReferenceFinalLists) {
-        if ((a->pReferenceFinalLists) && (b->pReferenceFinalLists)) {
-            checkEqual_VkVideoEncodeH265ReferenceListsEXT(a->pReferenceFinalLists,
-                                                          b->pReferenceFinalLists, onFail);
-        }
+    if (a->pStdReferenceFinalLists && b->pStdReferenceFinalLists) {
+        if (!((memcmp(a->pStdReferenceFinalLists, b->pStdReferenceFinalLists,
+                      sizeof(const StdVideoEncodeH265ReferenceListsInfo)) == 0))) {
+            onFail("a->pStdReferenceFinalLists (Error: Unequal dyn array)");
+        };
     }
-    if (!((memcmp(a->pSliceHeaderStd, b->pSliceHeaderStd,
-                  sizeof(const StdVideoEncodeH265SliceHeader)) == 0))) {
-        onFail("a->pSliceHeaderStd (Error: Unequal dyn array)");
+    if (!((memcmp(a->pStdSliceSegmentHeader, b->pStdSliceSegmentHeader,
+                  sizeof(const StdVideoEncodeH265SliceSegmentHeader)) == 0))) {
+        onFail("a->pStdSliceSegmentHeader (Error: Unequal dyn array)");
     };
 }
 
@@ -10789,74 +11998,56 @@ void checkEqual_VkVideoEncodeH265VclFrameInfoEXT(const VkVideoEncodeH265VclFrame
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((!(a->pReferenceFinalLists) && !(b->pReferenceFinalLists)) ||
-          ((a->pReferenceFinalLists) && (b->pReferenceFinalLists)))) {
-        onFail("a->pReferenceFinalLists (Error: Mismatch in optional field)");
+    if (!((!(a->pStdReferenceFinalLists) && !(b->pStdReferenceFinalLists)) ||
+          ((a->pStdReferenceFinalLists) && (b->pStdReferenceFinalLists)))) {
+        onFail("a->pStdReferenceFinalLists (Error: Mismatch in optional field)");
     };
-    if (a->pReferenceFinalLists && b->pReferenceFinalLists) {
-        if ((a->pReferenceFinalLists) && (b->pReferenceFinalLists)) {
-            checkEqual_VkVideoEncodeH265ReferenceListsEXT(a->pReferenceFinalLists,
-                                                          b->pReferenceFinalLists, onFail);
-        }
+    if (a->pStdReferenceFinalLists && b->pStdReferenceFinalLists) {
+        if (!((memcmp(a->pStdReferenceFinalLists, b->pStdReferenceFinalLists,
+                      sizeof(const StdVideoEncodeH265ReferenceListsInfo)) == 0))) {
+            onFail("a->pStdReferenceFinalLists (Error: Unequal dyn array)");
+        };
     }
-    if (!((a->naluSliceEntryCount) == (b->naluSliceEntryCount))) {
-        onFail("a->naluSliceEntryCount (Error: Value not equal)");
+    if (!((a->naluSliceSegmentEntryCount) == (b->naluSliceSegmentEntryCount))) {
+        onFail("a->naluSliceSegmentEntryCount (Error: Value not equal)");
     };
-    if ((a->pNaluSliceEntries) && (b->pNaluSliceEntries)) {
-        if (!((a->naluSliceEntryCount) == (b->naluSliceEntryCount))) {
-            onFail("a->pNaluSliceEntries (Error: Lengths not equal)");
+    if ((a->pNaluSliceSegmentEntries) && (b->pNaluSliceSegmentEntries)) {
+        if (!((a->naluSliceSegmentEntryCount) == (b->naluSliceSegmentEntryCount))) {
+            onFail("a->pNaluSliceSegmentEntries (Error: Lengths not equal)");
         };
-        if ((a->naluSliceEntryCount) == (b->naluSliceEntryCount)) {
+        if ((a->naluSliceSegmentEntryCount) == (b->naluSliceSegmentEntryCount)) {
             if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->naluSliceEntryCount; ++i) {
-                    checkEqual_VkVideoEncodeH265NaluSliceEXT(a->pNaluSliceEntries + i,
-                                                             b->pNaluSliceEntries + i, onFail);
+                for (uint32_t i = 0; i < (uint32_t)a->naluSliceSegmentEntryCount; ++i) {
+                    checkEqual_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+                        a->pNaluSliceSegmentEntries + i, b->pNaluSliceSegmentEntries + i, onFail);
                 }
             }
         }
     }
-    if (!((memcmp(a->pCurrentPictureInfo, b->pCurrentPictureInfo,
+    if (!((memcmp(a->pStdPictureInfo, b->pStdPictureInfo,
                   sizeof(const StdVideoEncodeH265PictureInfo)) == 0))) {
-        onFail("a->pCurrentPictureInfo (Error: Unequal dyn array)");
+        onFail("a->pStdPictureInfo (Error: Unequal dyn array)");
     };
 }
 
-void checkEqual_VkVideoEncodeH265EmitPictureParametersEXT(
-    const VkVideoEncodeH265EmitPictureParametersEXT* a,
-    const VkVideoEncodeH265EmitPictureParametersEXT* b, OnFailCompareFunc onFail) {
+void checkEqual_VkVideoEncodeH265DpbSlotInfoEXT(const VkVideoEncodeH265DpbSlotInfoEXT* a,
+                                                const VkVideoEncodeH265DpbSlotInfoEXT* b,
+                                                OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->vpsId) == (b->vpsId))) {
-        onFail("a->vpsId (Error: Value not equal)");
-    };
-    if (!((a->spsId) == (b->spsId))) {
-        onFail("a->spsId (Error: Value not equal)");
-    };
-    if (!((a->emitVpsEnable) == (b->emitVpsEnable))) {
-        onFail("a->emitVpsEnable (Error: Value not equal)");
-    };
-    if (!((a->emitSpsEnable) == (b->emitSpsEnable))) {
-        onFail("a->emitSpsEnable (Error: Value not equal)");
-    };
-    if (!((a->ppsIdEntryCount) == (b->ppsIdEntryCount))) {
-        onFail("a->ppsIdEntryCount (Error: Value not equal)");
-    };
-    if (!((a->ppsIdEntryCount) == (b->ppsIdEntryCount))) {
-        onFail("a->ppsIdEntries (Error: Lengths not equal)");
-    };
-    if (!((memcmp(a->ppsIdEntries, b->ppsIdEntries, a->ppsIdEntryCount * sizeof(const uint8_t)) ==
-           0))) {
-        onFail("a->ppsIdEntries (Error: Unequal dyn array)");
+    if (!((memcmp(a->pStdReferenceInfo, b->pStdReferenceInfo,
+                  sizeof(const StdVideoEncodeH265ReferenceInfo)) == 0))) {
+        onFail("a->pStdReferenceInfo (Error: Unequal dyn array)");
     };
 }
 
-void checkEqual_VkVideoEncodeH265ProfileEXT(const VkVideoEncodeH265ProfileEXT* a,
-                                            const VkVideoEncodeH265ProfileEXT* b,
-                                            OnFailCompareFunc onFail) {
+void checkEqual_VkVideoEncodeH265ProfileInfoEXT(const VkVideoEncodeH265ProfileInfoEXT* a,
+                                                const VkVideoEncodeH265ProfileInfoEXT* b,
+                                                OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
@@ -10868,178 +12059,87 @@ void checkEqual_VkVideoEncodeH265ProfileEXT(const VkVideoEncodeH265ProfileEXT* a
     };
 }
 
-#endif
-#ifdef VK_EXT_video_decode_h264
-void checkEqual_VkVideoDecodeH264ProfileEXT(const VkVideoDecodeH264ProfileEXT* a,
-                                            const VkVideoDecodeH264ProfileEXT* b,
-                                            OnFailCompareFunc onFail) {
+void checkEqual_VkVideoEncodeH265RateControlInfoEXT(const VkVideoEncodeH265RateControlInfoEXT* a,
+                                                    const VkVideoEncodeH265RateControlInfoEXT* b,
+                                                    OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->stdProfileIdc) == (b->stdProfileIdc))) {
-        onFail("a->stdProfileIdc (Error: Value not equal)");
-    };
-    if (!((a->pictureLayout) == (b->pictureLayout))) {
-        onFail("a->pictureLayout (Error: Value not equal)");
+    if (!((a->gopFrameCount) == (b->gopFrameCount))) {
+        onFail("a->gopFrameCount (Error: Value not equal)");
     };
-}
-
-void checkEqual_VkVideoDecodeH264CapabilitiesEXT(const VkVideoDecodeH264CapabilitiesEXT* a,
-                                                 const VkVideoDecodeH264CapabilitiesEXT* b,
-                                                 OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
+    if (!((a->idrPeriod) == (b->idrPeriod))) {
+        onFail("a->idrPeriod (Error: Value not equal)");
     };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->maxLevel) == (b->maxLevel))) {
-        onFail("a->maxLevel (Error: Value not equal)");
+    if (!((a->consecutiveBFrameCount) == (b->consecutiveBFrameCount))) {
+        onFail("a->consecutiveBFrameCount (Error: Value not equal)");
     };
-    checkEqual_VkOffset2D(&a->fieldOffsetGranularity, &b->fieldOffsetGranularity, onFail);
-    checkEqual_VkExtensionProperties(&a->stdExtensionVersion, &b->stdExtensionVersion, onFail);
-}
-
-void checkEqual_VkVideoDecodeH264SessionCreateInfoEXT(
-    const VkVideoDecodeH264SessionCreateInfoEXT* a, const VkVideoDecodeH264SessionCreateInfoEXT* b,
-    OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
+    if (!((a->rateControlStructure) == (b->rateControlStructure))) {
+        onFail("a->rateControlStructure (Error: Value not equal)");
     };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->flags) == (b->flags))) {
-        onFail("a->flags (Error: Value not equal)");
+    if (!((a->subLayerCount) == (b->subLayerCount))) {
+        onFail("a->subLayerCount (Error: Value not equal)");
     };
-    if ((a->pStdExtensionVersion) && (b->pStdExtensionVersion)) {
-        checkEqual_VkExtensionProperties(a->pStdExtensionVersion, b->pStdExtensionVersion, onFail);
-    }
 }
 
-void checkEqual_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    const VkVideoDecodeH264SessionParametersAddInfoEXT* a,
-    const VkVideoDecodeH264SessionParametersAddInfoEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
+void checkEqual_VkVideoEncodeH265QpEXT(const VkVideoEncodeH265QpEXT* a,
+                                       const VkVideoEncodeH265QpEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->qpI) == (b->qpI))) {
+        onFail("a->qpI (Error: Value not equal)");
     };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->spsStdCount) == (b->spsStdCount))) {
-        onFail("a->spsStdCount (Error: Value not equal)");
-    };
-    if (!((!(a->pSpsStd) && !(b->pSpsStd)) || ((a->pSpsStd) && (b->pSpsStd)))) {
-        onFail("a->pSpsStd (Error: Mismatch in optional field)");
-    };
-    if (a->pSpsStd && b->pSpsStd) {
-        if (!((a->spsStdCount) == (b->spsStdCount))) {
-            onFail("a->pSpsStd (Error: Lengths not equal)");
-        };
-        if (!((memcmp(a->pSpsStd, b->pSpsStd,
-                      a->spsStdCount * sizeof(const StdVideoH264SequenceParameterSet)) == 0))) {
-            onFail("a->pSpsStd (Error: Unequal dyn array)");
-        };
-    }
-    if (!((a->ppsStdCount) == (b->ppsStdCount))) {
-        onFail("a->ppsStdCount (Error: Value not equal)");
+    if (!((a->qpP) == (b->qpP))) {
+        onFail("a->qpP (Error: Value not equal)");
     };
-    if (!((!(a->pPpsStd) && !(b->pPpsStd)) || ((a->pPpsStd) && (b->pPpsStd)))) {
-        onFail("a->pPpsStd (Error: Mismatch in optional field)");
+    if (!((a->qpB) == (b->qpB))) {
+        onFail("a->qpB (Error: Value not equal)");
     };
-    if (a->pPpsStd && b->pPpsStd) {
-        if (!((a->ppsStdCount) == (b->ppsStdCount))) {
-            onFail("a->pPpsStd (Error: Lengths not equal)");
-        };
-        if (!((memcmp(a->pPpsStd, b->pPpsStd,
-                      a->ppsStdCount * sizeof(const StdVideoH264PictureParameterSet)) == 0))) {
-            onFail("a->pPpsStd (Error: Unequal dyn array)");
-        };
-    }
 }
 
-void checkEqual_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-    const VkVideoDecodeH264SessionParametersCreateInfoEXT* a,
-    const VkVideoDecodeH264SessionParametersCreateInfoEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->maxSpsStdCount) == (b->maxSpsStdCount))) {
-        onFail("a->maxSpsStdCount (Error: Value not equal)");
+void checkEqual_VkVideoEncodeH265FrameSizeEXT(const VkVideoEncodeH265FrameSizeEXT* a,
+                                              const VkVideoEncodeH265FrameSizeEXT* b,
+                                              OnFailCompareFunc onFail) {
+    if (!((a->frameISize) == (b->frameISize))) {
+        onFail("a->frameISize (Error: Value not equal)");
     };
-    if (!((a->maxPpsStdCount) == (b->maxPpsStdCount))) {
-        onFail("a->maxPpsStdCount (Error: Value not equal)");
+    if (!((a->framePSize) == (b->framePSize))) {
+        onFail("a->framePSize (Error: Value not equal)");
     };
-    if (!((!(a->pParametersAddInfo) && !(b->pParametersAddInfo)) ||
-          ((a->pParametersAddInfo) && (b->pParametersAddInfo)))) {
-        onFail("a->pParametersAddInfo (Error: Mismatch in optional field)");
+    if (!((a->frameBSize) == (b->frameBSize))) {
+        onFail("a->frameBSize (Error: Value not equal)");
     };
-    if (a->pParametersAddInfo && b->pParametersAddInfo) {
-        if ((a->pParametersAddInfo) && (b->pParametersAddInfo)) {
-            checkEqual_VkVideoDecodeH264SessionParametersAddInfoEXT(a->pParametersAddInfo,
-                                                                    b->pParametersAddInfo, onFail);
-        }
-    }
 }
 
-void checkEqual_VkVideoDecodeH264PictureInfoEXT(const VkVideoDecodeH264PictureInfoEXT* a,
-                                                const VkVideoDecodeH264PictureInfoEXT* b,
-                                                OnFailCompareFunc onFail) {
+void checkEqual_VkVideoEncodeH265RateControlLayerInfoEXT(
+    const VkVideoEncodeH265RateControlLayerInfoEXT* a,
+    const VkVideoEncodeH265RateControlLayerInfoEXT* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((memcmp(a->pStdPictureInfo, b->pStdPictureInfo,
-                  sizeof(const StdVideoDecodeH264PictureInfo)) == 0))) {
-        onFail("a->pStdPictureInfo (Error: Unequal dyn array)");
+    if (!((a->temporalId) == (b->temporalId))) {
+        onFail("a->temporalId (Error: Value not equal)");
     };
-    if (!((a->slicesCount) == (b->slicesCount))) {
-        onFail("a->slicesCount (Error: Value not equal)");
+    if (!((a->useInitialRcQp) == (b->useInitialRcQp))) {
+        onFail("a->useInitialRcQp (Error: Value not equal)");
     };
-    if (!((a->slicesCount) == (b->slicesCount))) {
-        onFail("a->pSlicesDataOffsets (Error: Lengths not equal)");
+    checkEqual_VkVideoEncodeH265QpEXT(&a->initialRcQp, &b->initialRcQp, onFail);
+    if (!((a->useMinQp) == (b->useMinQp))) {
+        onFail("a->useMinQp (Error: Value not equal)");
     };
-    if (!((memcmp(a->pSlicesDataOffsets, b->pSlicesDataOffsets,
-                  a->slicesCount * sizeof(const uint32_t)) == 0))) {
-        onFail("a->pSlicesDataOffsets (Error: Unequal dyn array)");
+    checkEqual_VkVideoEncodeH265QpEXT(&a->minQp, &b->minQp, onFail);
+    if (!((a->useMaxQp) == (b->useMaxQp))) {
+        onFail("a->useMaxQp (Error: Value not equal)");
     };
-}
-
-void checkEqual_VkVideoDecodeH264MvcEXT(const VkVideoDecodeH264MvcEXT* a,
-                                        const VkVideoDecodeH264MvcEXT* b,
-                                        OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((memcmp(a->pStdMvc, b->pStdMvc, sizeof(const StdVideoDecodeH264Mvc)) == 0))) {
-        onFail("a->pStdMvc (Error: Unequal dyn array)");
-    };
-}
-
-void checkEqual_VkVideoDecodeH264DpbSlotInfoEXT(const VkVideoDecodeH264DpbSlotInfoEXT* a,
-                                                const VkVideoDecodeH264DpbSlotInfoEXT* b,
-                                                OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((memcmp(a->pStdReferenceInfo, b->pStdReferenceInfo,
-                  sizeof(const StdVideoDecodeH264ReferenceInfo)) == 0))) {
-        onFail("a->pStdReferenceInfo (Error: Unequal dyn array)");
+    checkEqual_VkVideoEncodeH265QpEXT(&a->maxQp, &b->maxQp, onFail);
+    if (!((a->useMaxFrameSize) == (b->useMaxFrameSize))) {
+        onFail("a->useMaxFrameSize (Error: Value not equal)");
     };
+    checkEqual_VkVideoEncodeH265FrameSizeEXT(&a->maxFrameSize, &b->maxFrameSize, onFail);
 }
 
 #endif
@@ -11333,20 +12433,6 @@ void checkEqual_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* a,
 #ifdef VK_EXT_shader_subgroup_vote
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
-void checkEqual_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-    const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* a,
-    const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->textureCompressionASTC_HDR) == (b->textureCompressionASTC_HDR))) {
-        onFail("a->textureCompressionASTC_HDR (Error: Value not equal)");
-    };
-}
-
 #endif
 #ifdef VK_EXT_astc_decode_mode
 void checkEqual_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT* a,
@@ -11378,6 +12464,68 @@ void checkEqual_VkPhysicalDeviceASTCDecodeFeaturesEXT(
 }
 
 #endif
+#ifdef VK_EXT_pipeline_robustness
+void checkEqual_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* a,
+    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->pipelineRobustness) == (b->pipelineRobustness))) {
+        onFail("a->pipelineRobustness (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* a,
+    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->defaultRobustnessStorageBuffers) == (b->defaultRobustnessStorageBuffers))) {
+        onFail("a->defaultRobustnessStorageBuffers (Error: Value not equal)");
+    };
+    if (!((a->defaultRobustnessUniformBuffers) == (b->defaultRobustnessUniformBuffers))) {
+        onFail("a->defaultRobustnessUniformBuffers (Error: Value not equal)");
+    };
+    if (!((a->defaultRobustnessVertexInputs) == (b->defaultRobustnessVertexInputs))) {
+        onFail("a->defaultRobustnessVertexInputs (Error: Value not equal)");
+    };
+    if (!((a->defaultRobustnessImages) == (b->defaultRobustnessImages))) {
+        onFail("a->defaultRobustnessImages (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPipelineRobustnessCreateInfoEXT(const VkPipelineRobustnessCreateInfoEXT* a,
+                                                  const VkPipelineRobustnessCreateInfoEXT* b,
+                                                  OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->storageBuffers) == (b->storageBuffers))) {
+        onFail("a->storageBuffers (Error: Value not equal)");
+    };
+    if (!((a->uniformBuffers) == (b->uniformBuffers))) {
+        onFail("a->uniformBuffers (Error: Value not equal)");
+    };
+    if (!((a->vertexInputs) == (b->vertexInputs))) {
+        onFail("a->vertexInputs (Error: Value not equal)");
+    };
+    if (!((a->images) == (b->images))) {
+        onFail("a->images (Error: Value not equal)");
+    };
+}
+
+#endif
 #ifdef VK_EXT_conditional_rendering
 void checkEqual_VkConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT* a,
                                                    const VkConditionalRenderingBeginInfoEXT* b,
@@ -11703,21 +12851,15 @@ void checkEqual_VkPipelineViewportSwizzleStateCreateInfoNV(
     if (!((a->viewportCount) == (b->viewportCount))) {
         onFail("a->viewportCount (Error: Value not equal)");
     };
-    if (!((!(a->pViewportSwizzles) && !(b->pViewportSwizzles)) ||
-          ((a->pViewportSwizzles) && (b->pViewportSwizzles)))) {
-        onFail("a->pViewportSwizzles (Error: Mismatch in optional field)");
-    };
-    if (a->pViewportSwizzles && b->pViewportSwizzles) {
-        if ((a->pViewportSwizzles) && (b->pViewportSwizzles)) {
-            if (!((a->viewportCount) == (b->viewportCount))) {
-                onFail("a->pViewportSwizzles (Error: Lengths not equal)");
-            };
-            if ((a->viewportCount) == (b->viewportCount)) {
-                if (a) {
-                    for (uint32_t i = 0; i < (uint32_t)a->viewportCount; ++i) {
-                        checkEqual_VkViewportSwizzleNV(a->pViewportSwizzles + i,
-                                                       b->pViewportSwizzles + i, onFail);
-                    }
+    if ((a->pViewportSwizzles) && (b->pViewportSwizzles)) {
+        if (!((a->viewportCount) == (b->viewportCount))) {
+            onFail("a->pViewportSwizzles (Error: Lengths not equal)");
+        };
+        if ((a->viewportCount) == (b->viewportCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->viewportCount; ++i) {
+                    checkEqual_VkViewportSwizzleNV(a->pViewportSwizzles + i,
+                                                   b->pViewportSwizzles + i, onFail);
                 }
             }
         }
@@ -11955,8 +13097,6 @@ void checkEqual_VkMacOSSurfaceCreateInfoMVK(const VkMacOSSurfaceCreateInfoMVK* a
 }
 
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -12054,20 +13194,15 @@ void checkEqual_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessenger
     if (!((a->queueLabelCount) == (b->queueLabelCount))) {
         onFail("a->queueLabelCount (Error: Value not equal)");
     };
-    if (!((!(a->pQueueLabels) && !(b->pQueueLabels)) || ((a->pQueueLabels) && (b->pQueueLabels)))) {
-        onFail("a->pQueueLabels (Error: Mismatch in optional field)");
-    };
-    if (a->pQueueLabels && b->pQueueLabels) {
-        if ((a->pQueueLabels) && (b->pQueueLabels)) {
-            if (!((a->queueLabelCount) == (b->queueLabelCount))) {
-                onFail("a->pQueueLabels (Error: Lengths not equal)");
-            };
-            if ((a->queueLabelCount) == (b->queueLabelCount)) {
-                if (a) {
-                    for (uint32_t i = 0; i < (uint32_t)a->queueLabelCount; ++i) {
-                        checkEqual_VkDebugUtilsLabelEXT(a->pQueueLabels + i, b->pQueueLabels + i,
-                                                        onFail);
-                    }
+    if ((a->pQueueLabels) && (b->pQueueLabels)) {
+        if (!((a->queueLabelCount) == (b->queueLabelCount))) {
+            onFail("a->pQueueLabels (Error: Lengths not equal)");
+        };
+        if ((a->queueLabelCount) == (b->queueLabelCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->queueLabelCount; ++i) {
+                    checkEqual_VkDebugUtilsLabelEXT(a->pQueueLabels + i, b->pQueueLabels + i,
+                                                    onFail);
                 }
             }
         }
@@ -12075,21 +13210,15 @@ void checkEqual_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessenger
     if (!((a->cmdBufLabelCount) == (b->cmdBufLabelCount))) {
         onFail("a->cmdBufLabelCount (Error: Value not equal)");
     };
-    if (!((!(a->pCmdBufLabels) && !(b->pCmdBufLabels)) ||
-          ((a->pCmdBufLabels) && (b->pCmdBufLabels)))) {
-        onFail("a->pCmdBufLabels (Error: Mismatch in optional field)");
-    };
-    if (a->pCmdBufLabels && b->pCmdBufLabels) {
-        if ((a->pCmdBufLabels) && (b->pCmdBufLabels)) {
-            if (!((a->cmdBufLabelCount) == (b->cmdBufLabelCount))) {
-                onFail("a->pCmdBufLabels (Error: Lengths not equal)");
-            };
-            if ((a->cmdBufLabelCount) == (b->cmdBufLabelCount)) {
-                if (a) {
-                    for (uint32_t i = 0; i < (uint32_t)a->cmdBufLabelCount; ++i) {
-                        checkEqual_VkDebugUtilsLabelEXT(a->pCmdBufLabels + i, b->pCmdBufLabels + i,
-                                                        onFail);
-                    }
+    if ((a->pCmdBufLabels) && (b->pCmdBufLabels)) {
+        if (!((a->cmdBufLabelCount) == (b->cmdBufLabelCount))) {
+            onFail("a->pCmdBufLabels (Error: Lengths not equal)");
+        };
+        if ((a->cmdBufLabelCount) == (b->cmdBufLabelCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->cmdBufLabelCount; ++i) {
+                    checkEqual_VkDebugUtilsLabelEXT(a->pCmdBufLabels + i, b->pCmdBufLabels + i,
+                                                    onFail);
                 }
             }
         }
@@ -12097,20 +13226,15 @@ void checkEqual_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessenger
     if (!((a->objectCount) == (b->objectCount))) {
         onFail("a->objectCount (Error: Value not equal)");
     };
-    if (!((!(a->pObjects) && !(b->pObjects)) || ((a->pObjects) && (b->pObjects)))) {
-        onFail("a->pObjects (Error: Mismatch in optional field)");
-    };
-    if (a->pObjects && b->pObjects) {
-        if ((a->pObjects) && (b->pObjects)) {
-            if (!((a->objectCount) == (b->objectCount))) {
-                onFail("a->pObjects (Error: Lengths not equal)");
-            };
-            if ((a->objectCount) == (b->objectCount)) {
-                if (a) {
-                    for (uint32_t i = 0; i < (uint32_t)a->objectCount; ++i) {
-                        checkEqual_VkDebugUtilsObjectNameInfoEXT(a->pObjects + i, b->pObjects + i,
-                                                                 onFail);
-                    }
+    if ((a->pObjects) && (b->pObjects)) {
+        if (!((a->objectCount) == (b->objectCount))) {
+            onFail("a->pObjects (Error: Lengths not equal)");
+        };
+        if ((a->objectCount) == (b->objectCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->objectCount; ++i) {
+                    checkEqual_VkDebugUtilsObjectNameInfoEXT(a->pObjects + i, b->pObjects + i,
+                                                             onFail);
                 }
             }
         }
@@ -12319,82 +13443,6 @@ void checkEqual_VkAndroidHardwareBufferFormatProperties2ANDROID(
 #ifdef VK_AMD_shader_fragment_mask
 #endif
 #ifdef VK_EXT_inline_uniform_block
-void checkEqual_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* a,
-    const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->inlineUniformBlock) == (b->inlineUniformBlock))) {
-        onFail("a->inlineUniformBlock (Error: Value not equal)");
-    };
-    if (!((a->descriptorBindingInlineUniformBlockUpdateAfterBind) ==
-          (b->descriptorBindingInlineUniformBlockUpdateAfterBind))) {
-        onFail("a->descriptorBindingInlineUniformBlockUpdateAfterBind (Error: Value not equal)");
-    };
-}
-
-void checkEqual_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* a,
-    const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->maxInlineUniformBlockSize) == (b->maxInlineUniformBlockSize))) {
-        onFail("a->maxInlineUniformBlockSize (Error: Value not equal)");
-    };
-    if (!((a->maxPerStageDescriptorInlineUniformBlocks) ==
-          (b->maxPerStageDescriptorInlineUniformBlocks))) {
-        onFail("a->maxPerStageDescriptorInlineUniformBlocks (Error: Value not equal)");
-    };
-    if (!((a->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks) ==
-          (b->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks))) {
-        onFail(
-            "a->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks (Error: Value not equal)");
-    };
-    if (!((a->maxDescriptorSetInlineUniformBlocks) == (b->maxDescriptorSetInlineUniformBlocks))) {
-        onFail("a->maxDescriptorSetInlineUniformBlocks (Error: Value not equal)");
-    };
-    if (!((a->maxDescriptorSetUpdateAfterBindInlineUniformBlocks) ==
-          (b->maxDescriptorSetUpdateAfterBindInlineUniformBlocks))) {
-        onFail("a->maxDescriptorSetUpdateAfterBindInlineUniformBlocks (Error: Value not equal)");
-    };
-}
-
-void checkEqual_VkWriteDescriptorSetInlineUniformBlockEXT(
-    const VkWriteDescriptorSetInlineUniformBlockEXT* a,
-    const VkWriteDescriptorSetInlineUniformBlockEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->dataSize) == (b->dataSize))) {
-        onFail("a->dataSize (Error: Value not equal)");
-    };
-}
-
-void checkEqual_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* a,
-    const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->maxInlineUniformBlockBindings) == (b->maxInlineUniformBlockBindings))) {
-        onFail("a->maxInlineUniformBlockBindings (Error: Value not equal)");
-    };
-}
-
 #endif
 #ifdef VK_EXT_shader_stencil_export
 #endif
@@ -13567,20 +14615,6 @@ void checkEqual_VkFilterCubicImageViewImageFormatPropertiesEXT(
 #ifdef VK_QCOM_render_pass_shader_resolve
 #endif
 #ifdef VK_EXT_global_priority
-void checkEqual_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    const VkDeviceQueueGlobalPriorityCreateInfoEXT* a,
-    const VkDeviceQueueGlobalPriorityCreateInfoEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->globalPriority) == (b->globalPriority))) {
-        onFail("a->globalPriority (Error: Value not equal)");
-    };
-}
-
 #endif
 #ifdef VK_EXT_external_memory_host
 void checkEqual_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT* a,
@@ -13718,162 +14752,6 @@ void checkEqual_VkPhysicalDeviceShaderCorePropertiesAMD(
 }
 
 #endif
-#ifdef VK_EXT_video_decode_h265
-void checkEqual_VkVideoDecodeH265ProfileEXT(const VkVideoDecodeH265ProfileEXT* a,
-                                            const VkVideoDecodeH265ProfileEXT* b,
-                                            OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->stdProfileIdc) == (b->stdProfileIdc))) {
-        onFail("a->stdProfileIdc (Error: Value not equal)");
-    };
-}
-
-void checkEqual_VkVideoDecodeH265CapabilitiesEXT(const VkVideoDecodeH265CapabilitiesEXT* a,
-                                                 const VkVideoDecodeH265CapabilitiesEXT* b,
-                                                 OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->maxLevel) == (b->maxLevel))) {
-        onFail("a->maxLevel (Error: Value not equal)");
-    };
-    checkEqual_VkExtensionProperties(&a->stdExtensionVersion, &b->stdExtensionVersion, onFail);
-}
-
-void checkEqual_VkVideoDecodeH265SessionCreateInfoEXT(
-    const VkVideoDecodeH265SessionCreateInfoEXT* a, const VkVideoDecodeH265SessionCreateInfoEXT* b,
-    OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->flags) == (b->flags))) {
-        onFail("a->flags (Error: Value not equal)");
-    };
-    if ((a->pStdExtensionVersion) && (b->pStdExtensionVersion)) {
-        checkEqual_VkExtensionProperties(a->pStdExtensionVersion, b->pStdExtensionVersion, onFail);
-    }
-}
-
-void checkEqual_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    const VkVideoDecodeH265SessionParametersAddInfoEXT* a,
-    const VkVideoDecodeH265SessionParametersAddInfoEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->spsStdCount) == (b->spsStdCount))) {
-        onFail("a->spsStdCount (Error: Value not equal)");
-    };
-    if (!((!(a->pSpsStd) && !(b->pSpsStd)) || ((a->pSpsStd) && (b->pSpsStd)))) {
-        onFail("a->pSpsStd (Error: Mismatch in optional field)");
-    };
-    if (a->pSpsStd && b->pSpsStd) {
-        if (!((a->spsStdCount) == (b->spsStdCount))) {
-            onFail("a->pSpsStd (Error: Lengths not equal)");
-        };
-        if (!((memcmp(a->pSpsStd, b->pSpsStd,
-                      a->spsStdCount * sizeof(const StdVideoH265SequenceParameterSet)) == 0))) {
-            onFail("a->pSpsStd (Error: Unequal dyn array)");
-        };
-    }
-    if (!((a->ppsStdCount) == (b->ppsStdCount))) {
-        onFail("a->ppsStdCount (Error: Value not equal)");
-    };
-    if (!((!(a->pPpsStd) && !(b->pPpsStd)) || ((a->pPpsStd) && (b->pPpsStd)))) {
-        onFail("a->pPpsStd (Error: Mismatch in optional field)");
-    };
-    if (a->pPpsStd && b->pPpsStd) {
-        if (!((a->ppsStdCount) == (b->ppsStdCount))) {
-            onFail("a->pPpsStd (Error: Lengths not equal)");
-        };
-        if (!((memcmp(a->pPpsStd, b->pPpsStd,
-                      a->ppsStdCount * sizeof(const StdVideoH265PictureParameterSet)) == 0))) {
-            onFail("a->pPpsStd (Error: Unequal dyn array)");
-        };
-    }
-}
-
-void checkEqual_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    const VkVideoDecodeH265SessionParametersCreateInfoEXT* a,
-    const VkVideoDecodeH265SessionParametersCreateInfoEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->maxSpsStdCount) == (b->maxSpsStdCount))) {
-        onFail("a->maxSpsStdCount (Error: Value not equal)");
-    };
-    if (!((a->maxPpsStdCount) == (b->maxPpsStdCount))) {
-        onFail("a->maxPpsStdCount (Error: Value not equal)");
-    };
-    if (!((!(a->pParametersAddInfo) && !(b->pParametersAddInfo)) ||
-          ((a->pParametersAddInfo) && (b->pParametersAddInfo)))) {
-        onFail("a->pParametersAddInfo (Error: Mismatch in optional field)");
-    };
-    if (a->pParametersAddInfo && b->pParametersAddInfo) {
-        if ((a->pParametersAddInfo) && (b->pParametersAddInfo)) {
-            checkEqual_VkVideoDecodeH265SessionParametersAddInfoEXT(a->pParametersAddInfo,
-                                                                    b->pParametersAddInfo, onFail);
-        }
-    }
-}
-
-void checkEqual_VkVideoDecodeH265PictureInfoEXT(const VkVideoDecodeH265PictureInfoEXT* a,
-                                                const VkVideoDecodeH265PictureInfoEXT* b,
-                                                OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((memcmp(a->pStdPictureInfo, b->pStdPictureInfo, sizeof(StdVideoDecodeH265PictureInfo)) ==
-           0))) {
-        onFail("a->pStdPictureInfo (Error: Unequal dyn array)");
-    };
-    if (!((a->slicesCount) == (b->slicesCount))) {
-        onFail("a->slicesCount (Error: Value not equal)");
-    };
-    if (!((a->slicesCount) == (b->slicesCount))) {
-        onFail("a->pSlicesDataOffsets (Error: Lengths not equal)");
-    };
-    if (!((memcmp(a->pSlicesDataOffsets, b->pSlicesDataOffsets,
-                  a->slicesCount * sizeof(const uint32_t)) == 0))) {
-        onFail("a->pSlicesDataOffsets (Error: Unequal dyn array)");
-    };
-}
-
-void checkEqual_VkVideoDecodeH265DpbSlotInfoEXT(const VkVideoDecodeH265DpbSlotInfoEXT* a,
-                                                const VkVideoDecodeH265DpbSlotInfoEXT* b,
-                                                OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((memcmp(a->pStdReferenceInfo, b->pStdReferenceInfo,
-                  sizeof(const StdVideoDecodeH265ReferenceInfo)) == 0))) {
-        onFail("a->pStdReferenceInfo (Error: Unequal dyn array)");
-    };
-}
-
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 void checkEqual_VkDeviceMemoryOverallocationCreateInfoAMD(
     const VkDeviceMemoryOverallocationCreateInfoAMD* a,
@@ -13978,49 +14856,6 @@ void checkEqual_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP* a,
 
 #endif
 #ifdef VK_EXT_pipeline_creation_feedback
-void checkEqual_VkPipelineCreationFeedbackEXT(const VkPipelineCreationFeedbackEXT* a,
-                                              const VkPipelineCreationFeedbackEXT* b,
-                                              OnFailCompareFunc onFail) {
-    if (!((a->flags) == (b->flags))) {
-        onFail("a->flags (Error: Value not equal)");
-    };
-    if (!((a->duration) == (b->duration))) {
-        onFail("a->duration (Error: Value not equal)");
-    };
-}
-
-void checkEqual_VkPipelineCreationFeedbackCreateInfoEXT(
-    const VkPipelineCreationFeedbackCreateInfoEXT* a,
-    const VkPipelineCreationFeedbackCreateInfoEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if ((a->pPipelineCreationFeedback) && (b->pPipelineCreationFeedback)) {
-        checkEqual_VkPipelineCreationFeedbackEXT(a->pPipelineCreationFeedback,
-                                                 b->pPipelineCreationFeedback, onFail);
-    }
-    if (!((a->pipelineStageCreationFeedbackCount) == (b->pipelineStageCreationFeedbackCount))) {
-        onFail("a->pipelineStageCreationFeedbackCount (Error: Value not equal)");
-    };
-    if ((a->pPipelineStageCreationFeedbacks) && (b->pPipelineStageCreationFeedbacks)) {
-        if (!((a->pipelineStageCreationFeedbackCount) == (b->pipelineStageCreationFeedbackCount))) {
-            onFail("a->pPipelineStageCreationFeedbacks (Error: Lengths not equal)");
-        };
-        if ((a->pipelineStageCreationFeedbackCount) == (b->pipelineStageCreationFeedbackCount)) {
-            if (a) {
-                for (uint32_t i = 0; i < (uint32_t)a->pipelineStageCreationFeedbackCount; ++i) {
-                    checkEqual_VkPipelineCreationFeedbackEXT(a->pPipelineStageCreationFeedbacks + i,
-                                                             b->pPipelineStageCreationFeedbacks + i,
-                                                             onFail);
-                }
-            }
-        }
-    }
-}
-
 #endif
 #ifdef VK_NV_shader_subgroup_partitioned
 #endif
@@ -14124,20 +14959,6 @@ void checkEqual_VkDrawMeshTasksIndirectCommandNV(const VkDrawMeshTasksIndirectCo
 
 #endif
 #ifdef VK_NV_fragment_shader_barycentric
-void checkEqual_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* a,
-    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->fragmentShaderBarycentric) == (b->fragmentShaderBarycentric))) {
-        onFail("a->fragmentShaderBarycentric (Error: Value not equal)");
-    };
-}
-
 #endif
 #ifdef VK_NV_shader_image_footprint
 void checkEqual_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -14536,60 +15357,6 @@ void checkEqual_VkRenderPassFragmentDensityMapCreateInfoEXT(
 #ifdef VK_GOOGLE_decorate_string
 #endif
 #ifdef VK_EXT_subgroup_size_control
-void checkEqual_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* a,
-    const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->subgroupSizeControl) == (b->subgroupSizeControl))) {
-        onFail("a->subgroupSizeControl (Error: Value not equal)");
-    };
-    if (!((a->computeFullSubgroups) == (b->computeFullSubgroups))) {
-        onFail("a->computeFullSubgroups (Error: Value not equal)");
-    };
-}
-
-void checkEqual_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* a,
-    const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->minSubgroupSize) == (b->minSubgroupSize))) {
-        onFail("a->minSubgroupSize (Error: Value not equal)");
-    };
-    if (!((a->maxSubgroupSize) == (b->maxSubgroupSize))) {
-        onFail("a->maxSubgroupSize (Error: Value not equal)");
-    };
-    if (!((a->maxComputeWorkgroupSubgroups) == (b->maxComputeWorkgroupSubgroups))) {
-        onFail("a->maxComputeWorkgroupSubgroups (Error: Value not equal)");
-    };
-    if (!((a->requiredSubgroupSizeStages) == (b->requiredSubgroupSizeStages))) {
-        onFail("a->requiredSubgroupSizeStages (Error: Value not equal)");
-    };
-}
-
-void checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* a,
-    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->requiredSubgroupSize) == (b->requiredSubgroupSize))) {
-        onFail("a->requiredSubgroupSize (Error: Value not equal)");
-    };
-}
-
 #endif
 #ifdef VK_AMD_shader_core_properties2
 void checkEqual_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -14748,32 +15515,6 @@ void checkEqual_VkBufferDeviceAddressCreateInfoEXT(const VkBufferDeviceAddressCr
 
 #endif
 #ifdef VK_EXT_tooling_info
-void checkEqual_VkPhysicalDeviceToolPropertiesEXT(const VkPhysicalDeviceToolPropertiesEXT* a,
-                                                  const VkPhysicalDeviceToolPropertiesEXT* b,
-                                                  OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((memcmp(a->name, b->name, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char)) == 0))) {
-        onFail("a->name (Error: Unequal static array)");
-    };
-    if (!((memcmp(a->version, b->version, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char)) == 0))) {
-        onFail("a->version (Error: Unequal static array)");
-    };
-    if (!((a->purposes) == (b->purposes))) {
-        onFail("a->purposes (Error: Value not equal)");
-    };
-    if (!((memcmp(a->description, b->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)) == 0))) {
-        onFail("a->description (Error: Unequal static array)");
-    };
-    if (!((memcmp(a->layer, b->layer, VK_MAX_EXTENSION_NAME_SIZE * sizeof(char)) == 0))) {
-        onFail("a->layer (Error: Unequal static array)");
-    };
-}
-
 #endif
 #ifdef VK_EXT_separate_stencil_usage
 #endif
@@ -15286,21 +16027,194 @@ void checkEqual_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
 }
 
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-void checkEqual_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
-    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* a,
-    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* b, OnFailCompareFunc onFail) {
+#ifdef VK_EXT_surface_maintenance1
+void checkEqual_VkSurfacePresentModeEXT(const VkSurfacePresentModeEXT* a,
+                                        const VkSurfacePresentModeEXT* b,
+                                        OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->shaderDemoteToHelperInvocation) == (b->shaderDemoteToHelperInvocation))) {
-        onFail("a->shaderDemoteToHelperInvocation (Error: Value not equal)");
+    if (!((a->presentMode) == (b->presentMode))) {
+        onFail("a->presentMode (Error: Value not equal)");
     };
 }
 
+void checkEqual_VkSurfacePresentScalingCapabilitiesEXT(
+    const VkSurfacePresentScalingCapabilitiesEXT* a,
+    const VkSurfacePresentScalingCapabilitiesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->supportedPresentScaling) == (b->supportedPresentScaling))) {
+        onFail("a->supportedPresentScaling (Error: Value not equal)");
+    };
+    if (!((a->supportedPresentGravityX) == (b->supportedPresentGravityX))) {
+        onFail("a->supportedPresentGravityX (Error: Value not equal)");
+    };
+    if (!((a->supportedPresentGravityY) == (b->supportedPresentGravityY))) {
+        onFail("a->supportedPresentGravityY (Error: Value not equal)");
+    };
+    checkEqual_VkExtent2D(&a->minScaledImageExtent, &b->minScaledImageExtent, onFail);
+    checkEqual_VkExtent2D(&a->maxScaledImageExtent, &b->maxScaledImageExtent, onFail);
+}
+
+void checkEqual_VkSurfacePresentModeCompatibilityEXT(const VkSurfacePresentModeCompatibilityEXT* a,
+                                                     const VkSurfacePresentModeCompatibilityEXT* b,
+                                                     OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->presentModeCount) == (b->presentModeCount))) {
+        onFail("a->presentModeCount (Error: Value not equal)");
+    };
+    if (!((!(a->pPresentModes) && !(b->pPresentModes)) ||
+          ((a->pPresentModes) && (b->pPresentModes)))) {
+        onFail("a->pPresentModes (Error: Mismatch in optional field)");
+    };
+    if (a->pPresentModes && b->pPresentModes) {
+        if (!((a->presentModeCount) == (b->presentModeCount))) {
+            onFail("a->pPresentModes (Error: Lengths not equal)");
+        };
+        if (!((memcmp(a->pPresentModes, b->pPresentModes,
+                      a->presentModeCount * sizeof(VkPresentModeKHR)) == 0))) {
+            onFail("a->pPresentModes (Error: Unequal dyn array)");
+        };
+    }
+}
+
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+void checkEqual_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* a,
+    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->swapchainMaintenance1) == (b->swapchainMaintenance1))) {
+        onFail("a->swapchainMaintenance1 (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkSwapchainPresentFenceInfoEXT(const VkSwapchainPresentFenceInfoEXT* a,
+                                               const VkSwapchainPresentFenceInfoEXT* b,
+                                               OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->swapchainCount) == (b->swapchainCount))) {
+        onFail("a->swapchainCount (Error: Value not equal)");
+    };
+    if (!((a->swapchainCount) == (b->swapchainCount))) {
+        onFail("a->pFences (Error: Lengths not equal)");
+    };
+    if (!((memcmp(a->pFences, b->pFences, a->swapchainCount * sizeof(const VkFence)) == 0))) {
+        onFail("a->pFences (Error: Unequal dyn array)");
+    };
+}
+
+void checkEqual_VkSwapchainPresentModesCreateInfoEXT(const VkSwapchainPresentModesCreateInfoEXT* a,
+                                                     const VkSwapchainPresentModesCreateInfoEXT* b,
+                                                     OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->presentModeCount) == (b->presentModeCount))) {
+        onFail("a->presentModeCount (Error: Value not equal)");
+    };
+    if (!((a->presentModeCount) == (b->presentModeCount))) {
+        onFail("a->pPresentModes (Error: Lengths not equal)");
+    };
+    if (!((memcmp(a->pPresentModes, b->pPresentModes,
+                  a->presentModeCount * sizeof(const VkPresentModeKHR)) == 0))) {
+        onFail("a->pPresentModes (Error: Unequal dyn array)");
+    };
+}
+
+void checkEqual_VkSwapchainPresentModeInfoEXT(const VkSwapchainPresentModeInfoEXT* a,
+                                              const VkSwapchainPresentModeInfoEXT* b,
+                                              OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->swapchainCount) == (b->swapchainCount))) {
+        onFail("a->swapchainCount (Error: Value not equal)");
+    };
+    if (!((a->swapchainCount) == (b->swapchainCount))) {
+        onFail("a->pPresentModes (Error: Lengths not equal)");
+    };
+    if (!((memcmp(a->pPresentModes, b->pPresentModes,
+                  a->swapchainCount * sizeof(const VkPresentModeKHR)) == 0))) {
+        onFail("a->pPresentModes (Error: Unequal dyn array)");
+    };
+}
+
+void checkEqual_VkSwapchainPresentScalingCreateInfoEXT(
+    const VkSwapchainPresentScalingCreateInfoEXT* a,
+    const VkSwapchainPresentScalingCreateInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->scalingBehavior) == (b->scalingBehavior))) {
+        onFail("a->scalingBehavior (Error: Value not equal)");
+    };
+    if (!((a->presentGravityX) == (b->presentGravityX))) {
+        onFail("a->presentGravityX (Error: Value not equal)");
+    };
+    if (!((a->presentGravityY) == (b->presentGravityY))) {
+        onFail("a->presentGravityY (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkReleaseSwapchainImagesInfoEXT(const VkReleaseSwapchainImagesInfoEXT* a,
+                                                const VkReleaseSwapchainImagesInfoEXT* b,
+                                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->swapchain) == (b->swapchain))) {
+        onFail("a->swapchain (Error: Value not equal)");
+    };
+    if (!((a->imageIndexCount) == (b->imageIndexCount))) {
+        onFail("a->imageIndexCount (Error: Value not equal)");
+    };
+    if (!((a->imageIndexCount) == (b->imageIndexCount))) {
+        onFail("a->pImageIndices (Error: Lengths not equal)");
+    };
+    if (!((memcmp(a->pImageIndices, b->pImageIndices,
+                  a->imageIndexCount * sizeof(const uint32_t)) == 0))) {
+        onFail("a->pImageIndices (Error: Unequal dyn array)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_shader_demote_to_helper_invocation
 #endif
 #ifdef VK_NV_device_generated_commands
 void checkEqual_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
@@ -15738,33 +16652,6 @@ void checkEqual_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
     };
 }
 
-void checkEqual_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* a,
-    const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* b, OnFailCompareFunc onFail) {
-    if (!((a->sType) == (b->sType))) {
-        onFail("a->sType (Error: Value not equal)");
-    };
-    if (a->pNext) {
-        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
-    }
-    if (!((a->storageTexelBufferOffsetAlignmentBytes) ==
-          (b->storageTexelBufferOffsetAlignmentBytes))) {
-        onFail("a->storageTexelBufferOffsetAlignmentBytes (Error: Value not equal)");
-    };
-    if (!((a->storageTexelBufferOffsetSingleTexelAlignment) ==
-          (b->storageTexelBufferOffsetSingleTexelAlignment))) {
-        onFail("a->storageTexelBufferOffsetSingleTexelAlignment (Error: Value not equal)");
-    };
-    if (!((a->uniformTexelBufferOffsetAlignmentBytes) ==
-          (b->uniformTexelBufferOffsetAlignmentBytes))) {
-        onFail("a->uniformTexelBufferOffsetAlignmentBytes (Error: Value not equal)");
-    };
-    if (!((a->uniformTexelBufferOffsetSingleTexelAlignment) ==
-          (b->uniformTexelBufferOffsetSingleTexelAlignment))) {
-        onFail("a->uniformTexelBufferOffsetSingleTexelAlignment (Error: Value not equal)");
-    };
-}
-
 #endif
 #ifdef VK_QCOM_render_pass_transform
 void checkEqual_VkRenderPassTransformBeginInfoQCOM(const VkRenderPassTransformBeginInfoQCOM* a,
@@ -15955,38 +16842,72 @@ void checkEqual_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
-#ifdef VK_EXT_private_data
-void checkEqual_VkPhysicalDevicePrivateDataFeaturesEXT(
-    const VkPhysicalDevicePrivateDataFeaturesEXT* a,
-    const VkPhysicalDevicePrivateDataFeaturesEXT* b, OnFailCompareFunc onFail) {
+#ifdef VK_NV_present_barrier
+void checkEqual_VkPhysicalDevicePresentBarrierFeaturesNV(
+    const VkPhysicalDevicePresentBarrierFeaturesNV* a,
+    const VkPhysicalDevicePresentBarrierFeaturesNV* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->privateData) == (b->privateData))) {
-        onFail("a->privateData (Error: Value not equal)");
+    if (!((a->presentBarrier) == (b->presentBarrier))) {
+        onFail("a->presentBarrier (Error: Value not equal)");
     };
 }
 
-void checkEqual_VkDevicePrivateDataCreateInfoEXT(const VkDevicePrivateDataCreateInfoEXT* a,
-                                                 const VkDevicePrivateDataCreateInfoEXT* b,
-                                                 OnFailCompareFunc onFail) {
+void checkEqual_VkSurfaceCapabilitiesPresentBarrierNV(
+    const VkSurfaceCapabilitiesPresentBarrierNV* a, const VkSurfaceCapabilitiesPresentBarrierNV* b,
+    OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->privateDataSlotRequestCount) == (b->privateDataSlotRequestCount))) {
-        onFail("a->privateDataSlotRequestCount (Error: Value not equal)");
+    if (!((a->presentBarrierSupported) == (b->presentBarrierSupported))) {
+        onFail("a->presentBarrierSupported (Error: Value not equal)");
     };
 }
 
-void checkEqual_VkPrivateDataSlotCreateInfoEXT(const VkPrivateDataSlotCreateInfoEXT* a,
-                                               const VkPrivateDataSlotCreateInfoEXT* b,
-                                               OnFailCompareFunc onFail) {
+void checkEqual_VkSwapchainPresentBarrierCreateInfoNV(
+    const VkSwapchainPresentBarrierCreateInfoNV* a, const VkSwapchainPresentBarrierCreateInfoNV* b,
+    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->presentBarrierEnable) == (b->presentBarrierEnable))) {
+        onFail("a->presentBarrierEnable (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_private_data
+#endif
+#ifdef VK_EXT_pipeline_creation_cache_control
+#endif
+#ifdef VK_NV_device_diagnostics_config
+void checkEqual_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* a,
+    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->diagnosticsConfig) == (b->diagnosticsConfig))) {
+        onFail("a->diagnosticsConfig (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDeviceDiagnosticsConfigCreateInfoNV(
+    const VkDeviceDiagnosticsConfigCreateInfoNV* a, const VkDeviceDiagnosticsConfigCreateInfoNV* b,
+    OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
@@ -15999,39 +16920,560 @@ void checkEqual_VkPrivateDataSlotCreateInfoEXT(const VkPrivateDataSlotCreateInfo
 }
 
 #endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-void checkEqual_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
-    const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* a,
-    const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* b, OnFailCompareFunc onFail) {
+#ifdef VK_QCOM_render_pass_store_ops
+#endif
+#ifdef VK_NV_low_latency
+void checkEqual_VkQueryLowLatencySupportNV(const VkQueryLowLatencySupportNV* a,
+                                           const VkQueryLowLatencySupportNV* b,
+                                           OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->pipelineCreationCacheControl) == (b->pipelineCreationCacheControl))) {
-        onFail("a->pipelineCreationCacheControl (Error: Value not equal)");
+}
+
+#endif
+#ifdef VK_EXT_metal_objects
+void checkEqual_VkExportMetalObjectCreateInfoEXT(const VkExportMetalObjectCreateInfoEXT* a,
+                                                 const VkExportMetalObjectCreateInfoEXT* b,
+                                                 OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->exportObjectType) == (b->exportObjectType))) {
+        onFail("a->exportObjectType (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkExportMetalObjectsInfoEXT(const VkExportMetalObjectsInfoEXT* a,
+                                            const VkExportMetalObjectsInfoEXT* b,
+                                            OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+}
+
+void checkEqual_VkExportMetalDeviceInfoEXT(const VkExportMetalDeviceInfoEXT* a,
+                                           const VkExportMetalDeviceInfoEXT* b,
+                                           OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->mtlDevice) == (b->mtlDevice))) {
+        onFail("a->mtlDevice (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkExportMetalCommandQueueInfoEXT(const VkExportMetalCommandQueueInfoEXT* a,
+                                                 const VkExportMetalCommandQueueInfoEXT* b,
+                                                 OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->queue) == (b->queue))) {
+        onFail("a->queue (Error: Value not equal)");
+    };
+    if (!((a->mtlCommandQueue) == (b->mtlCommandQueue))) {
+        onFail("a->mtlCommandQueue (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkExportMetalBufferInfoEXT(const VkExportMetalBufferInfoEXT* a,
+                                           const VkExportMetalBufferInfoEXT* b,
+                                           OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->memory) == (b->memory))) {
+        onFail("a->memory (Error: Value not equal)");
+    };
+    if (!((a->mtlBuffer) == (b->mtlBuffer))) {
+        onFail("a->mtlBuffer (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkImportMetalBufferInfoEXT(const VkImportMetalBufferInfoEXT* a,
+                                           const VkImportMetalBufferInfoEXT* b,
+                                           OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->mtlBuffer) == (b->mtlBuffer))) {
+        onFail("a->mtlBuffer (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkExportMetalTextureInfoEXT(const VkExportMetalTextureInfoEXT* a,
+                                            const VkExportMetalTextureInfoEXT* b,
+                                            OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->image) == (b->image))) {
+        onFail("a->image (Error: Value not equal)");
+    };
+    if (!((a->imageView) == (b->imageView))) {
+        onFail("a->imageView (Error: Value not equal)");
+    };
+    if (!((a->bufferView) == (b->bufferView))) {
+        onFail("a->bufferView (Error: Value not equal)");
+    };
+    if (!((a->plane) == (b->plane))) {
+        onFail("a->plane (Error: Value not equal)");
+    };
+    if (!((a->mtlTexture) == (b->mtlTexture))) {
+        onFail("a->mtlTexture (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkImportMetalTextureInfoEXT(const VkImportMetalTextureInfoEXT* a,
+                                            const VkImportMetalTextureInfoEXT* b,
+                                            OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->plane) == (b->plane))) {
+        onFail("a->plane (Error: Value not equal)");
+    };
+    if (!((a->mtlTexture) == (b->mtlTexture))) {
+        onFail("a->mtlTexture (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkExportMetalIOSurfaceInfoEXT(const VkExportMetalIOSurfaceInfoEXT* a,
+                                              const VkExportMetalIOSurfaceInfoEXT* b,
+                                              OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->image) == (b->image))) {
+        onFail("a->image (Error: Value not equal)");
+    };
+    if (!((a->ioSurface) == (b->ioSurface))) {
+        onFail("a->ioSurface (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkImportMetalIOSurfaceInfoEXT(const VkImportMetalIOSurfaceInfoEXT* a,
+                                              const VkImportMetalIOSurfaceInfoEXT* b,
+                                              OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->ioSurface) == (b->ioSurface))) {
+        onFail("a->ioSurface (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkExportMetalSharedEventInfoEXT(const VkExportMetalSharedEventInfoEXT* a,
+                                                const VkExportMetalSharedEventInfoEXT* b,
+                                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->semaphore) == (b->semaphore))) {
+        onFail("a->semaphore (Error: Value not equal)");
+    };
+    if (!((a->event) == (b->event))) {
+        onFail("a->event (Error: Value not equal)");
+    };
+    if (!((a->mtlSharedEvent) == (b->mtlSharedEvent))) {
+        onFail("a->mtlSharedEvent (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkImportMetalSharedEventInfoEXT(const VkImportMetalSharedEventInfoEXT* a,
+                                                const VkImportMetalSharedEventInfoEXT* b,
+                                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->mtlSharedEvent) == (b->mtlSharedEvent))) {
+        onFail("a->mtlSharedEvent (Error: Value not equal)");
     };
 }
 
 #endif
-#ifdef VK_NV_device_diagnostics_config
-void checkEqual_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
-    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* a,
-    const VkPhysicalDeviceDiagnosticsConfigFeaturesNV* b, OnFailCompareFunc onFail) {
+#ifdef VK_EXT_descriptor_buffer
+void checkEqual_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+    const VkPhysicalDeviceDescriptorBufferPropertiesEXT* a,
+    const VkPhysicalDeviceDescriptorBufferPropertiesEXT* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->diagnosticsConfig) == (b->diagnosticsConfig))) {
-        onFail("a->diagnosticsConfig (Error: Value not equal)");
+    if (!((a->combinedImageSamplerDescriptorSingleArray) ==
+          (b->combinedImageSamplerDescriptorSingleArray))) {
+        onFail("a->combinedImageSamplerDescriptorSingleArray (Error: Value not equal)");
+    };
+    if (!((a->bufferlessPushDescriptors) == (b->bufferlessPushDescriptors))) {
+        onFail("a->bufferlessPushDescriptors (Error: Value not equal)");
+    };
+    if (!((a->allowSamplerImageViewPostSubmitCreation) ==
+          (b->allowSamplerImageViewPostSubmitCreation))) {
+        onFail("a->allowSamplerImageViewPostSubmitCreation (Error: Value not equal)");
+    };
+    if (!((a->descriptorBufferOffsetAlignment) == (b->descriptorBufferOffsetAlignment))) {
+        onFail("a->descriptorBufferOffsetAlignment (Error: Value not equal)");
+    };
+    if (!((a->maxDescriptorBufferBindings) == (b->maxDescriptorBufferBindings))) {
+        onFail("a->maxDescriptorBufferBindings (Error: Value not equal)");
+    };
+    if (!((a->maxResourceDescriptorBufferBindings) == (b->maxResourceDescriptorBufferBindings))) {
+        onFail("a->maxResourceDescriptorBufferBindings (Error: Value not equal)");
+    };
+    if (!((a->maxSamplerDescriptorBufferBindings) == (b->maxSamplerDescriptorBufferBindings))) {
+        onFail("a->maxSamplerDescriptorBufferBindings (Error: Value not equal)");
+    };
+    if (!((a->maxEmbeddedImmutableSamplerBindings) == (b->maxEmbeddedImmutableSamplerBindings))) {
+        onFail("a->maxEmbeddedImmutableSamplerBindings (Error: Value not equal)");
+    };
+    if (!((a->maxEmbeddedImmutableSamplers) == (b->maxEmbeddedImmutableSamplers))) {
+        onFail("a->maxEmbeddedImmutableSamplers (Error: Value not equal)");
+    };
+    if (!((a->bufferCaptureReplayDescriptorDataSize) ==
+          (b->bufferCaptureReplayDescriptorDataSize))) {
+        onFail("a->bufferCaptureReplayDescriptorDataSize (Error: Value not equal)");
+    };
+    if (!((a->imageCaptureReplayDescriptorDataSize) == (b->imageCaptureReplayDescriptorDataSize))) {
+        onFail("a->imageCaptureReplayDescriptorDataSize (Error: Value not equal)");
+    };
+    if (!((a->imageViewCaptureReplayDescriptorDataSize) ==
+          (b->imageViewCaptureReplayDescriptorDataSize))) {
+        onFail("a->imageViewCaptureReplayDescriptorDataSize (Error: Value not equal)");
+    };
+    if (!((a->samplerCaptureReplayDescriptorDataSize) ==
+          (b->samplerCaptureReplayDescriptorDataSize))) {
+        onFail("a->samplerCaptureReplayDescriptorDataSize (Error: Value not equal)");
+    };
+    if (!((a->accelerationStructureCaptureReplayDescriptorDataSize) ==
+          (b->accelerationStructureCaptureReplayDescriptorDataSize))) {
+        onFail("a->accelerationStructureCaptureReplayDescriptorDataSize (Error: Value not equal)");
+    };
+    if (!((a->samplerDescriptorSize) == (b->samplerDescriptorSize))) {
+        onFail("a->samplerDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->combinedImageSamplerDescriptorSize) == (b->combinedImageSamplerDescriptorSize))) {
+        onFail("a->combinedImageSamplerDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->sampledImageDescriptorSize) == (b->sampledImageDescriptorSize))) {
+        onFail("a->sampledImageDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->storageImageDescriptorSize) == (b->storageImageDescriptorSize))) {
+        onFail("a->storageImageDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->uniformTexelBufferDescriptorSize) == (b->uniformTexelBufferDescriptorSize))) {
+        onFail("a->uniformTexelBufferDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->robustUniformTexelBufferDescriptorSize) ==
+          (b->robustUniformTexelBufferDescriptorSize))) {
+        onFail("a->robustUniformTexelBufferDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->storageTexelBufferDescriptorSize) == (b->storageTexelBufferDescriptorSize))) {
+        onFail("a->storageTexelBufferDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->robustStorageTexelBufferDescriptorSize) ==
+          (b->robustStorageTexelBufferDescriptorSize))) {
+        onFail("a->robustStorageTexelBufferDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->uniformBufferDescriptorSize) == (b->uniformBufferDescriptorSize))) {
+        onFail("a->uniformBufferDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->robustUniformBufferDescriptorSize) == (b->robustUniformBufferDescriptorSize))) {
+        onFail("a->robustUniformBufferDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->storageBufferDescriptorSize) == (b->storageBufferDescriptorSize))) {
+        onFail("a->storageBufferDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->robustStorageBufferDescriptorSize) == (b->robustStorageBufferDescriptorSize))) {
+        onFail("a->robustStorageBufferDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->inputAttachmentDescriptorSize) == (b->inputAttachmentDescriptorSize))) {
+        onFail("a->inputAttachmentDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->accelerationStructureDescriptorSize) == (b->accelerationStructureDescriptorSize))) {
+        onFail("a->accelerationStructureDescriptorSize (Error: Value not equal)");
+    };
+    if (!((a->maxSamplerDescriptorBufferRange) == (b->maxSamplerDescriptorBufferRange))) {
+        onFail("a->maxSamplerDescriptorBufferRange (Error: Value not equal)");
+    };
+    if (!((a->maxResourceDescriptorBufferRange) == (b->maxResourceDescriptorBufferRange))) {
+        onFail("a->maxResourceDescriptorBufferRange (Error: Value not equal)");
+    };
+    if (!((a->samplerDescriptorBufferAddressSpaceSize) ==
+          (b->samplerDescriptorBufferAddressSpaceSize))) {
+        onFail("a->samplerDescriptorBufferAddressSpaceSize (Error: Value not equal)");
+    };
+    if (!((a->resourceDescriptorBufferAddressSpaceSize) ==
+          (b->resourceDescriptorBufferAddressSpaceSize))) {
+        onFail("a->resourceDescriptorBufferAddressSpaceSize (Error: Value not equal)");
+    };
+    if (!((a->descriptorBufferAddressSpaceSize) == (b->descriptorBufferAddressSpaceSize))) {
+        onFail("a->descriptorBufferAddressSpaceSize (Error: Value not equal)");
     };
 }
 
-void checkEqual_VkDeviceDiagnosticsConfigCreateInfoNV(
-    const VkDeviceDiagnosticsConfigCreateInfoNV* a, const VkDeviceDiagnosticsConfigCreateInfoNV* b,
+void checkEqual_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* a,
+    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->combinedImageSamplerDensityMapDescriptorSize) ==
+          (b->combinedImageSamplerDensityMapDescriptorSize))) {
+        onFail("a->combinedImageSamplerDensityMapDescriptorSize (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    const VkPhysicalDeviceDescriptorBufferFeaturesEXT* a,
+    const VkPhysicalDeviceDescriptorBufferFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->descriptorBuffer) == (b->descriptorBuffer))) {
+        onFail("a->descriptorBuffer (Error: Value not equal)");
+    };
+    if (!((a->descriptorBufferCaptureReplay) == (b->descriptorBufferCaptureReplay))) {
+        onFail("a->descriptorBufferCaptureReplay (Error: Value not equal)");
+    };
+    if (!((a->descriptorBufferImageLayoutIgnored) == (b->descriptorBufferImageLayoutIgnored))) {
+        onFail("a->descriptorBufferImageLayoutIgnored (Error: Value not equal)");
+    };
+    if (!((a->descriptorBufferPushDescriptors) == (b->descriptorBufferPushDescriptors))) {
+        onFail("a->descriptorBufferPushDescriptors (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDescriptorAddressInfoEXT(const VkDescriptorAddressInfoEXT* a,
+                                           const VkDescriptorAddressInfoEXT* b,
+                                           OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->address) == (b->address))) {
+        onFail("a->address (Error: Value not equal)");
+    };
+    if (!((a->range) == (b->range))) {
+        onFail("a->range (Error: Value not equal)");
+    };
+    if (!((a->format) == (b->format))) {
+        onFail("a->format (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDescriptorBufferBindingInfoEXT(const VkDescriptorBufferBindingInfoEXT* a,
+                                                 const VkDescriptorBufferBindingInfoEXT* b,
+                                                 OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->address) == (b->address))) {
+        onFail("a->address (Error: Value not equal)");
+    };
+    if (!((a->usage) == (b->usage))) {
+        onFail("a->usage (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* a,
+    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->buffer) == (b->buffer))) {
+        onFail("a->buffer (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDescriptorDataEXT(const VkDescriptorDataEXT* a, const VkDescriptorDataEXT* b,
+                                    OnFailCompareFunc onFail) {
+    if (!((memcmp(a->pSampler, b->pSampler, sizeof(const VkSampler)) == 0))) {
+        onFail("a->pSampler (Error: Unequal dyn array)");
+    };
+    if ((a->pCombinedImageSampler) && (b->pCombinedImageSampler)) {
+        checkEqual_VkDescriptorImageInfo(a->pCombinedImageSampler, b->pCombinedImageSampler,
+                                         onFail);
+    }
+    if ((a->pInputAttachmentImage) && (b->pInputAttachmentImage)) {
+        checkEqual_VkDescriptorImageInfo(a->pInputAttachmentImage, b->pInputAttachmentImage,
+                                         onFail);
+    }
+    if (!((!(a->pSampledImage) && !(b->pSampledImage)) ||
+          ((a->pSampledImage) && (b->pSampledImage)))) {
+        onFail("a->pSampledImage (Error: Mismatch in optional field)");
+    };
+    if (a->pSampledImage && b->pSampledImage) {
+        if ((a->pSampledImage) && (b->pSampledImage)) {
+            checkEqual_VkDescriptorImageInfo(a->pSampledImage, b->pSampledImage, onFail);
+        }
+    }
+    if (!((!(a->pStorageImage) && !(b->pStorageImage)) ||
+          ((a->pStorageImage) && (b->pStorageImage)))) {
+        onFail("a->pStorageImage (Error: Mismatch in optional field)");
+    };
+    if (a->pStorageImage && b->pStorageImage) {
+        if ((a->pStorageImage) && (b->pStorageImage)) {
+            checkEqual_VkDescriptorImageInfo(a->pStorageImage, b->pStorageImage, onFail);
+        }
+    }
+    if (!((!(a->pUniformTexelBuffer) && !(b->pUniformTexelBuffer)) ||
+          ((a->pUniformTexelBuffer) && (b->pUniformTexelBuffer)))) {
+        onFail("a->pUniformTexelBuffer (Error: Mismatch in optional field)");
+    };
+    if (a->pUniformTexelBuffer && b->pUniformTexelBuffer) {
+        if ((a->pUniformTexelBuffer) && (b->pUniformTexelBuffer)) {
+            checkEqual_VkDescriptorAddressInfoEXT(a->pUniformTexelBuffer, b->pUniformTexelBuffer,
+                                                  onFail);
+        }
+    }
+    if (!((!(a->pStorageTexelBuffer) && !(b->pStorageTexelBuffer)) ||
+          ((a->pStorageTexelBuffer) && (b->pStorageTexelBuffer)))) {
+        onFail("a->pStorageTexelBuffer (Error: Mismatch in optional field)");
+    };
+    if (a->pStorageTexelBuffer && b->pStorageTexelBuffer) {
+        if ((a->pStorageTexelBuffer) && (b->pStorageTexelBuffer)) {
+            checkEqual_VkDescriptorAddressInfoEXT(a->pStorageTexelBuffer, b->pStorageTexelBuffer,
+                                                  onFail);
+        }
+    }
+    if (!((!(a->pUniformBuffer) && !(b->pUniformBuffer)) ||
+          ((a->pUniformBuffer) && (b->pUniformBuffer)))) {
+        onFail("a->pUniformBuffer (Error: Mismatch in optional field)");
+    };
+    if (a->pUniformBuffer && b->pUniformBuffer) {
+        if ((a->pUniformBuffer) && (b->pUniformBuffer)) {
+            checkEqual_VkDescriptorAddressInfoEXT(a->pUniformBuffer, b->pUniformBuffer, onFail);
+        }
+    }
+    if (!((!(a->pStorageBuffer) && !(b->pStorageBuffer)) ||
+          ((a->pStorageBuffer) && (b->pStorageBuffer)))) {
+        onFail("a->pStorageBuffer (Error: Mismatch in optional field)");
+    };
+    if (a->pStorageBuffer && b->pStorageBuffer) {
+        if ((a->pStorageBuffer) && (b->pStorageBuffer)) {
+            checkEqual_VkDescriptorAddressInfoEXT(a->pStorageBuffer, b->pStorageBuffer, onFail);
+        }
+    }
+    if (!((a->accelerationStructure) == (b->accelerationStructure))) {
+        onFail("a->accelerationStructure (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* a,
+                                       const VkDescriptorGetInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->type) == (b->type))) {
+        onFail("a->type (Error: Value not equal)");
+    };
+    checkEqual_VkDescriptorDataEXT(&a->data, &b->data, onFail);
+}
+
+void checkEqual_VkBufferCaptureDescriptorDataInfoEXT(const VkBufferCaptureDescriptorDataInfoEXT* a,
+                                                     const VkBufferCaptureDescriptorDataInfoEXT* b,
+                                                     OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->buffer) == (b->buffer))) {
+        onFail("a->buffer (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkImageCaptureDescriptorDataInfoEXT(const VkImageCaptureDescriptorDataInfoEXT* a,
+                                                    const VkImageCaptureDescriptorDataInfoEXT* b,
+                                                    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->image) == (b->image))) {
+        onFail("a->image (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkImageViewCaptureDescriptorDataInfoEXT(
+    const VkImageViewCaptureDescriptorDataInfoEXT* a,
+    const VkImageViewCaptureDescriptorDataInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->imageView) == (b->imageView))) {
+        onFail("a->imageView (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkSamplerCaptureDescriptorDataInfoEXT(
+    const VkSamplerCaptureDescriptorDataInfoEXT* a, const VkSamplerCaptureDescriptorDataInfoEXT* b,
     OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
@@ -16039,13 +17481,105 @@ void checkEqual_VkDeviceDiagnosticsConfigCreateInfoNV(
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
+    if (!((a->sampler) == (b->sampler))) {
+        onFail("a->sampler (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    const VkOpaqueCaptureDescriptorDataCreateInfoEXT* a,
+    const VkOpaqueCaptureDescriptorDataCreateInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+}
+
+void checkEqual_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* a,
+    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->accelerationStructure) == (b->accelerationStructure))) {
+        onFail("a->accelerationStructure (Error: Value not equal)");
+    };
+    if (!((a->accelerationStructureNV) == (b->accelerationStructureNV))) {
+        onFail("a->accelerationStructureNV (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+void checkEqual_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* a,
+    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->graphicsPipelineLibrary) == (b->graphicsPipelineLibrary))) {
+        onFail("a->graphicsPipelineLibrary (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* a,
+    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->graphicsPipelineLibraryFastLinking) == (b->graphicsPipelineLibraryFastLinking))) {
+        onFail("a->graphicsPipelineLibraryFastLinking (Error: Value not equal)");
+    };
+    if (!((a->graphicsPipelineLibraryIndependentInterpolationDecoration) ==
+          (b->graphicsPipelineLibraryIndependentInterpolationDecoration))) {
+        onFail(
+            "a->graphicsPipelineLibraryIndependentInterpolationDecoration (Error: Value not "
+            "equal)");
+    };
+}
+
+void checkEqual_VkGraphicsPipelineLibraryCreateInfoEXT(
+    const VkGraphicsPipelineLibraryCreateInfoEXT* a,
+    const VkGraphicsPipelineLibraryCreateInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
     if (!((a->flags) == (b->flags))) {
         onFail("a->flags (Error: Value not equal)");
     };
 }
 
 #endif
-#ifdef VK_QCOM_render_pass_store_ops
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+void checkEqual_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* a,
+    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->shaderEarlyAndLateFragmentTests) == (b->shaderEarlyAndLateFragmentTests))) {
+        onFail("a->shaderEarlyAndLateFragmentTests (Error: Value not equal)");
+    };
+}
+
 #endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void checkEqual_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -16357,17 +17891,106 @@ void checkEqual_VkCopyCommandTransformInfoQCOM(const VkCopyCommandTransformInfoQ
 
 #endif
 #ifdef VK_EXT_image_robustness
-void checkEqual_VkPhysicalDeviceImageRobustnessFeaturesEXT(
-    const VkPhysicalDeviceImageRobustnessFeaturesEXT* a,
-    const VkPhysicalDeviceImageRobustnessFeaturesEXT* b, OnFailCompareFunc onFail) {
+#endif
+#ifdef VK_EXT_image_compression_control
+void checkEqual_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* a,
+    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->robustImageAccess) == (b->robustImageAccess))) {
-        onFail("a->robustImageAccess (Error: Value not equal)");
+    if (!((a->imageCompressionControl) == (b->imageCompressionControl))) {
+        onFail("a->imageCompressionControl (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkImageCompressionControlEXT(const VkImageCompressionControlEXT* a,
+                                             const VkImageCompressionControlEXT* b,
+                                             OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+    if (!((a->compressionControlPlaneCount) == (b->compressionControlPlaneCount))) {
+        onFail("a->compressionControlPlaneCount (Error: Value not equal)");
+    };
+    if (!((!(a->pFixedRateFlags) && !(b->pFixedRateFlags)) ||
+          ((a->pFixedRateFlags) && (b->pFixedRateFlags)))) {
+        onFail("a->pFixedRateFlags (Error: Mismatch in optional field)");
+    };
+    if (a->pFixedRateFlags && b->pFixedRateFlags) {
+        if (!((a->compressionControlPlaneCount) == (b->compressionControlPlaneCount))) {
+            onFail("a->pFixedRateFlags (Error: Lengths not equal)");
+        };
+        if (!((memcmp(a->pFixedRateFlags, b->pFixedRateFlags,
+                      a->compressionControlPlaneCount *
+                          sizeof(VkImageCompressionFixedRateFlagsEXT)) == 0))) {
+            onFail("a->pFixedRateFlags (Error: Unequal dyn array)");
+        };
+    }
+}
+
+void checkEqual_VkSubresourceLayout2EXT(const VkSubresourceLayout2EXT* a,
+                                        const VkSubresourceLayout2EXT* b,
+                                        OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    checkEqual_VkSubresourceLayout(&a->subresourceLayout, &b->subresourceLayout, onFail);
+}
+
+void checkEqual_VkImageSubresource2EXT(const VkImageSubresource2EXT* a,
+                                       const VkImageSubresource2EXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    checkEqual_VkImageSubresource(&a->imageSubresource, &b->imageSubresource, onFail);
+}
+
+void checkEqual_VkImageCompressionPropertiesEXT(const VkImageCompressionPropertiesEXT* a,
+                                                const VkImageCompressionPropertiesEXT* b,
+                                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->imageCompressionFlags) == (b->imageCompressionFlags))) {
+        onFail("a->imageCompressionFlags (Error: Value not equal)");
+    };
+    if (!((a->imageCompressionFixedRateFlags) == (b->imageCompressionFixedRateFlags))) {
+        onFail("a->imageCompressionFixedRateFlags (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+void checkEqual_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* a,
+    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->attachmentFeedbackLoopLayout) == (b->attachmentFeedbackLoopLayout))) {
+        onFail("a->attachmentFeedbackLoopLayout (Error: Value not equal)");
     };
 }
 
@@ -16391,6 +18014,171 @@ void checkEqual_VkPhysicalDevice4444FormatsFeaturesEXT(
 }
 
 #endif
+#ifdef VK_EXT_device_fault
+void checkEqual_VkPhysicalDeviceFaultFeaturesEXT(const VkPhysicalDeviceFaultFeaturesEXT* a,
+                                                 const VkPhysicalDeviceFaultFeaturesEXT* b,
+                                                 OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->deviceFault) == (b->deviceFault))) {
+        onFail("a->deviceFault (Error: Value not equal)");
+    };
+    if (!((a->deviceFaultVendorBinary) == (b->deviceFaultVendorBinary))) {
+        onFail("a->deviceFaultVendorBinary (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDeviceFaultCountsEXT(const VkDeviceFaultCountsEXT* a,
+                                       const VkDeviceFaultCountsEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->addressInfoCount) == (b->addressInfoCount))) {
+        onFail("a->addressInfoCount (Error: Value not equal)");
+    };
+    if (!((a->vendorInfoCount) == (b->vendorInfoCount))) {
+        onFail("a->vendorInfoCount (Error: Value not equal)");
+    };
+    if (!((a->vendorBinarySize) == (b->vendorBinarySize))) {
+        onFail("a->vendorBinarySize (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDeviceFaultAddressInfoEXT(const VkDeviceFaultAddressInfoEXT* a,
+                                            const VkDeviceFaultAddressInfoEXT* b,
+                                            OnFailCompareFunc onFail) {
+    if (!((a->addressType) == (b->addressType))) {
+        onFail("a->addressType (Error: Value not equal)");
+    };
+    if (!((a->reportedAddress) == (b->reportedAddress))) {
+        onFail("a->reportedAddress (Error: Value not equal)");
+    };
+    if (!((a->addressPrecision) == (b->addressPrecision))) {
+        onFail("a->addressPrecision (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDeviceFaultVendorInfoEXT(const VkDeviceFaultVendorInfoEXT* a,
+                                           const VkDeviceFaultVendorInfoEXT* b,
+                                           OnFailCompareFunc onFail) {
+    if (!((memcmp(a->description, b->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)) == 0))) {
+        onFail("a->description (Error: Unequal static array)");
+    };
+    if (!((a->vendorFaultCode) == (b->vendorFaultCode))) {
+        onFail("a->vendorFaultCode (Error: Value not equal)");
+    };
+    if (!((a->vendorFaultData) == (b->vendorFaultData))) {
+        onFail("a->vendorFaultData (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDeviceFaultInfoEXT(const VkDeviceFaultInfoEXT* a, const VkDeviceFaultInfoEXT* b,
+                                     OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((memcmp(a->description, b->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)) == 0))) {
+        onFail("a->description (Error: Unequal static array)");
+    };
+    if (!((!(a->pAddressInfos) && !(b->pAddressInfos)) ||
+          ((a->pAddressInfos) && (b->pAddressInfos)))) {
+        onFail("a->pAddressInfos (Error: Mismatch in optional field)");
+    };
+    if (a->pAddressInfos && b->pAddressInfos) {
+        if ((a->pAddressInfos) && (b->pAddressInfos)) {
+            checkEqual_VkDeviceFaultAddressInfoEXT(a->pAddressInfos, b->pAddressInfos, onFail);
+        }
+    }
+    if (!((!(a->pVendorInfos) && !(b->pVendorInfos)) || ((a->pVendorInfos) && (b->pVendorInfos)))) {
+        onFail("a->pVendorInfos (Error: Mismatch in optional field)");
+    };
+    if (a->pVendorInfos && b->pVendorInfos) {
+        if ((a->pVendorInfos) && (b->pVendorInfos)) {
+            checkEqual_VkDeviceFaultVendorInfoEXT(a->pVendorInfos, b->pVendorInfos, onFail);
+        }
+    }
+    if (!((!(a->pVendorBinaryData) && !(b->pVendorBinaryData)) ||
+          ((a->pVendorBinaryData) && (b->pVendorBinaryData)))) {
+        onFail("a->pVendorBinaryData (Error: Mismatch in optional field)");
+    };
+}
+
+void checkEqual_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    const VkDeviceFaultVendorBinaryHeaderVersionOneEXT* a,
+    const VkDeviceFaultVendorBinaryHeaderVersionOneEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->headerSize) == (b->headerSize))) {
+        onFail("a->headerSize (Error: Value not equal)");
+    };
+    if (!((a->headerVersion) == (b->headerVersion))) {
+        onFail("a->headerVersion (Error: Value not equal)");
+    };
+    if (!((a->vendorID) == (b->vendorID))) {
+        onFail("a->vendorID (Error: Value not equal)");
+    };
+    if (!((a->deviceID) == (b->deviceID))) {
+        onFail("a->deviceID (Error: Value not equal)");
+    };
+    if (!((a->driverVersion) == (b->driverVersion))) {
+        onFail("a->driverVersion (Error: Value not equal)");
+    };
+    if (!((memcmp(a->pipelineCacheUUID, b->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t)) ==
+           0))) {
+        onFail("a->pipelineCacheUUID (Error: Unequal static array)");
+    };
+    if (!((a->applicationNameOffset) == (b->applicationNameOffset))) {
+        onFail("a->applicationNameOffset (Error: Value not equal)");
+    };
+    if (!((a->applicationVersion) == (b->applicationVersion))) {
+        onFail("a->applicationVersion (Error: Value not equal)");
+    };
+    if (!((a->engineNameOffset) == (b->engineNameOffset))) {
+        onFail("a->engineNameOffset (Error: Value not equal)");
+    };
+    if (!((a->engineVersion) == (b->engineVersion))) {
+        onFail("a->engineVersion (Error: Value not equal)");
+    };
+    if (!((a->apiVersion) == (b->apiVersion))) {
+        onFail("a->apiVersion (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+void checkEqual_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* a,
+    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* b,
+    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->rasterizationOrderColorAttachmentAccess) ==
+          (b->rasterizationOrderColorAttachmentAccess))) {
+        onFail("a->rasterizationOrderColorAttachmentAccess (Error: Value not equal)");
+    };
+    if (!((a->rasterizationOrderDepthAttachmentAccess) ==
+          (b->rasterizationOrderDepthAttachmentAccess))) {
+        onFail("a->rasterizationOrderDepthAttachmentAccess (Error: Value not equal)");
+    };
+    if (!((a->rasterizationOrderStencilAttachmentAccess) ==
+          (b->rasterizationOrderStencilAttachmentAccess))) {
+        onFail("a->rasterizationOrderStencilAttachmentAccess (Error: Value not equal)");
+    };
+}
+
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 void checkEqual_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
     const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* a,
@@ -16442,9 +18230,9 @@ void checkEqual_VkDirectFBSurfaceCreateInfoEXT(const VkDirectFBSurfaceCreateInfo
 
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-void checkEqual_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
-    const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* a,
-    const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* b, OnFailCompareFunc onFail) {
+void checkEqual_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
+    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* a,
+    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
@@ -16456,9 +18244,9 @@ void checkEqual_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
     };
 }
 
-void checkEqual_VkMutableDescriptorTypeListVALVE(const VkMutableDescriptorTypeListVALVE* a,
-                                                 const VkMutableDescriptorTypeListVALVE* b,
-                                                 OnFailCompareFunc onFail) {
+void checkEqual_VkMutableDescriptorTypeListEXT(const VkMutableDescriptorTypeListEXT* a,
+                                               const VkMutableDescriptorTypeListEXT* b,
+                                               OnFailCompareFunc onFail) {
     if (!((a->descriptorTypeCount) == (b->descriptorTypeCount))) {
         onFail("a->descriptorTypeCount (Error: Value not equal)");
     };
@@ -16471,9 +18259,9 @@ void checkEqual_VkMutableDescriptorTypeListVALVE(const VkMutableDescriptorTypeLi
     };
 }
 
-void checkEqual_VkMutableDescriptorTypeCreateInfoVALVE(
-    const VkMutableDescriptorTypeCreateInfoVALVE* a,
-    const VkMutableDescriptorTypeCreateInfoVALVE* b, OnFailCompareFunc onFail) {
+void checkEqual_VkMutableDescriptorTypeCreateInfoEXT(const VkMutableDescriptorTypeCreateInfoEXT* a,
+                                                     const VkMutableDescriptorTypeCreateInfoEXT* b,
+                                                     OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
@@ -16490,9 +18278,9 @@ void checkEqual_VkMutableDescriptorTypeCreateInfoVALVE(
         if ((a->mutableDescriptorTypeListCount) == (b->mutableDescriptorTypeListCount)) {
             if (a) {
                 for (uint32_t i = 0; i < (uint32_t)a->mutableDescriptorTypeListCount; ++i) {
-                    checkEqual_VkMutableDescriptorTypeListVALVE(a->pMutableDescriptorTypeLists + i,
-                                                                b->pMutableDescriptorTypeLists + i,
-                                                                onFail);
+                    checkEqual_VkMutableDescriptorTypeListEXT(a->pMutableDescriptorTypeLists + i,
+                                                              b->pMutableDescriptorTypeLists + i,
+                                                              onFail);
                 }
             }
         }
@@ -16593,6 +18381,75 @@ void checkEqual_VkPhysicalDeviceDrmPropertiesEXT(const VkPhysicalDeviceDrmProper
 }
 
 #endif
+#ifdef VK_EXT_device_address_binding_report
+void checkEqual_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* a,
+    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->reportAddressBinding) == (b->reportAddressBinding))) {
+        onFail("a->reportAddressBinding (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDeviceAddressBindingCallbackDataEXT(
+    const VkDeviceAddressBindingCallbackDataEXT* a, const VkDeviceAddressBindingCallbackDataEXT* b,
+    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+    if (!((a->baseAddress) == (b->baseAddress))) {
+        onFail("a->baseAddress (Error: Value not equal)");
+    };
+    if (!((a->size) == (b->size))) {
+        onFail("a->size (Error: Value not equal)");
+    };
+    if (!((a->bindingType) == (b->bindingType))) {
+        onFail("a->bindingType (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_depth_clip_control
+void checkEqual_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    const VkPhysicalDeviceDepthClipControlFeaturesEXT* a,
+    const VkPhysicalDeviceDepthClipControlFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->depthClipControl) == (b->depthClipControl))) {
+        onFail("a->depthClipControl (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    const VkPipelineViewportDepthClipControlCreateInfoEXT* a,
+    const VkPipelineViewportDepthClipControlCreateInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->negativeOneToOne) == (b->negativeOneToOne))) {
+        onFail("a->negativeOneToOne (Error: Value not equal)");
+    };
+}
+
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 void checkEqual_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
     const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* a,
@@ -16892,7 +18749,17 @@ void checkEqual_VkImageFormatConstraintsInfoFUCHSIA(const VkImageFormatConstrain
         onFail("a->colorSpaceCount (Error: Value not equal)");
     };
     if ((a->pColorSpaces) && (b->pColorSpaces)) {
-        checkEqual_VkSysmemColorSpaceFUCHSIA(a->pColorSpaces, b->pColorSpaces, onFail);
+        if (!((a->colorSpaceCount) == (b->colorSpaceCount))) {
+            onFail("a->pColorSpaces (Error: Lengths not equal)");
+        };
+        if ((a->colorSpaceCount) == (b->colorSpaceCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->colorSpaceCount; ++i) {
+                    checkEqual_VkSysmemColorSpaceFUCHSIA(a->pColorSpaces + i, b->pColorSpaces + i,
+                                                         onFail);
+                }
+            }
+        }
     }
 }
 
@@ -17026,6 +18893,86 @@ void checkEqual_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
 }
 
 #endif
+#ifdef VK_EXT_pipeline_properties
+void checkEqual_VkPipelinePropertiesIdentifierEXT(const VkPipelinePropertiesIdentifierEXT* a,
+                                                  const VkPipelinePropertiesIdentifierEXT* b,
+                                                  OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((memcmp(a->pipelineIdentifier, b->pipelineIdentifier, VK_UUID_SIZE * sizeof(uint8_t)) ==
+           0))) {
+        onFail("a->pipelineIdentifier (Error: Unequal static array)");
+    };
+}
+
+void checkEqual_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    const VkPhysicalDevicePipelinePropertiesFeaturesEXT* a,
+    const VkPhysicalDevicePipelinePropertiesFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->pipelinePropertiesIdentifier) == (b->pipelinePropertiesIdentifier))) {
+        onFail("a->pipelinePropertiesIdentifier (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+void checkEqual_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* a,
+    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* b,
+    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->multisampledRenderToSingleSampled) == (b->multisampledRenderToSingleSampled))) {
+        onFail("a->multisampledRenderToSingleSampled (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkSubpassResolvePerformanceQueryEXT(const VkSubpassResolvePerformanceQueryEXT* a,
+                                                    const VkSubpassResolvePerformanceQueryEXT* b,
+                                                    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->optimal) == (b->optimal))) {
+        onFail("a->optimal (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkMultisampledRenderToSingleSampledInfoEXT(
+    const VkMultisampledRenderToSingleSampledInfoEXT* a,
+    const VkMultisampledRenderToSingleSampledInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->multisampledRenderToSingleSampledEnable) ==
+          (b->multisampledRenderToSingleSampledEnable))) {
+        onFail("a->multisampledRenderToSingleSampledEnable (Error: Value not equal)");
+    };
+    if (!((a->rasterizationSamples) == (b->rasterizationSamples))) {
+        onFail("a->rasterizationSamples (Error: Value not equal)");
+    };
+}
+
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void checkEqual_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
     const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* a,
@@ -17118,6 +19065,30 @@ void checkEqual_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCrea
 }
 
 #endif
+#ifdef VK_EXT_primitives_generated_query
+void checkEqual_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* a,
+    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->primitivesGeneratedQuery) == (b->primitivesGeneratedQuery))) {
+        onFail("a->primitivesGeneratedQuery (Error: Value not equal)");
+    };
+    if (!((a->primitivesGeneratedQueryWithRasterizerDiscard) ==
+          (b->primitivesGeneratedQueryWithRasterizerDiscard))) {
+        onFail("a->primitivesGeneratedQueryWithRasterizerDiscard (Error: Value not equal)");
+    };
+    if (!((a->primitivesGeneratedQueryWithNonZeroStreams) ==
+          (b->primitivesGeneratedQueryWithNonZeroStreams))) {
+        onFail("a->primitivesGeneratedQueryWithNonZeroStreams (Error: Value not equal)");
+    };
+}
+
+#endif
 #ifdef VK_GOOGLE_gfxstream
 void checkEqual_VkImportColorBufferGOOGLE(const VkImportColorBufferGOOGLE* a,
                                           const VkImportColorBufferGOOGLE* b,
@@ -17167,35 +19138,33 @@ void checkEqual_VkCreateBlobGOOGLE(const VkCreateBlobGOOGLE* a, const VkCreateBl
 
 #endif
 #ifdef VK_EXT_global_priority_query
-void checkEqual_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
-    const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* a,
-    const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* b, OnFailCompareFunc onFail) {
+#endif
+#ifdef VK_EXT_image_view_min_lod
+void checkEqual_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
+    const VkPhysicalDeviceImageViewMinLodFeaturesEXT* a,
+    const VkPhysicalDeviceImageViewMinLodFeaturesEXT* b, OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->globalPriorityQuery) == (b->globalPriorityQuery))) {
-        onFail("a->globalPriorityQuery (Error: Value not equal)");
+    if (!((a->minLod) == (b->minLod))) {
+        onFail("a->minLod (Error: Value not equal)");
     };
 }
 
-void checkEqual_VkQueueFamilyGlobalPriorityPropertiesEXT(
-    const VkQueueFamilyGlobalPriorityPropertiesEXT* a,
-    const VkQueueFamilyGlobalPriorityPropertiesEXT* b, OnFailCompareFunc onFail) {
+void checkEqual_VkImageViewMinLodCreateInfoEXT(const VkImageViewMinLodCreateInfoEXT* a,
+                                               const VkImageViewMinLodCreateInfoEXT* b,
+                                               OnFailCompareFunc onFail) {
     if (!((a->sType) == (b->sType))) {
         onFail("a->sType (Error: Value not equal)");
     };
     if (a->pNext) {
         checkEqual_extension_struct(a->pNext, b->pNext, onFail);
     }
-    if (!((a->priorityCount) == (b->priorityCount))) {
-        onFail("a->priorityCount (Error: Value not equal)");
-    };
-    if (!((memcmp(a->priorities, b->priorities,
-                  VK_MAX_GLOBAL_PRIORITY_SIZE_EXT * sizeof(VkQueueGlobalPriorityEXT)) == 0))) {
-        onFail("a->priorities (Error: Unequal static array)");
+    if (!((a->minLod) == (b->minLod))) {
+        onFail("a->minLod (Error: Value not equal)");
     };
 }
 
@@ -17254,8 +19223,504 @@ void checkEqual_VkMultiDrawIndexedInfoEXT(const VkMultiDrawIndexedInfoEXT* a,
 }
 
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+void checkEqual_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* a,
+    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->image2DViewOf3D) == (b->image2DViewOf3D))) {
+        onFail("a->image2DViewOf3D (Error: Value not equal)");
+    };
+    if (!((a->sampler2DViewOf3D) == (b->sampler2DViewOf3D))) {
+        onFail("a->sampler2DViewOf3D (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_shader_tile_image
+void checkEqual_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    const VkPhysicalDeviceShaderTileImageFeaturesEXT* a,
+    const VkPhysicalDeviceShaderTileImageFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->shaderTileImageColorReadAccess) == (b->shaderTileImageColorReadAccess))) {
+        onFail("a->shaderTileImageColorReadAccess (Error: Value not equal)");
+    };
+    if (!((a->shaderTileImageDepthReadAccess) == (b->shaderTileImageDepthReadAccess))) {
+        onFail("a->shaderTileImageDepthReadAccess (Error: Value not equal)");
+    };
+    if (!((a->shaderTileImageStencilReadAccess) == (b->shaderTileImageStencilReadAccess))) {
+        onFail("a->shaderTileImageStencilReadAccess (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    const VkPhysicalDeviceShaderTileImagePropertiesEXT* a,
+    const VkPhysicalDeviceShaderTileImagePropertiesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->shaderTileImageCoherentReadAccelerated) ==
+          (b->shaderTileImageCoherentReadAccelerated))) {
+        onFail("a->shaderTileImageCoherentReadAccelerated (Error: Value not equal)");
+    };
+    if (!((a->shaderTileImageReadSampleFromPixelRateInvocation) ==
+          (b->shaderTileImageReadSampleFromPixelRateInvocation))) {
+        onFail("a->shaderTileImageReadSampleFromPixelRateInvocation (Error: Value not equal)");
+    };
+    if (!((a->shaderTileImageReadFromHelperInvocation) ==
+          (b->shaderTileImageReadFromHelperInvocation))) {
+        onFail("a->shaderTileImageReadFromHelperInvocation (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_opacity_micromap
+void checkEqual_VkMicromapUsageEXT(const VkMicromapUsageEXT* a, const VkMicromapUsageEXT* b,
+                                   OnFailCompareFunc onFail) {
+    if (!((a->count) == (b->count))) {
+        onFail("a->count (Error: Value not equal)");
+    };
+    if (!((a->subdivisionLevel) == (b->subdivisionLevel))) {
+        onFail("a->subdivisionLevel (Error: Value not equal)");
+    };
+    if (!((a->format) == (b->format))) {
+        onFail("a->format (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* a,
+                                         const VkDeviceOrHostAddressKHR* b,
+                                         OnFailCompareFunc onFail) {
+    if (!((a->deviceAddress) == (b->deviceAddress))) {
+        onFail("a->deviceAddress (Error: Value not equal)");
+    };
+    if (!((!(a->hostAddress) && !(b->hostAddress)) || ((a->hostAddress) && (b->hostAddress)))) {
+        onFail("a->hostAddress (Error: Mismatch in optional field)");
+    };
+}
+
+void checkEqual_VkMicromapBuildInfoEXT(const VkMicromapBuildInfoEXT* a,
+                                       const VkMicromapBuildInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->type) == (b->type))) {
+        onFail("a->type (Error: Value not equal)");
+    };
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+    if (!((a->mode) == (b->mode))) {
+        onFail("a->mode (Error: Value not equal)");
+    };
+    if (!((a->dstMicromap) == (b->dstMicromap))) {
+        onFail("a->dstMicromap (Error: Value not equal)");
+    };
+    if (!((a->usageCountsCount) == (b->usageCountsCount))) {
+        onFail("a->usageCountsCount (Error: Value not equal)");
+    };
+    if (!((!(a->pUsageCounts) && !(b->pUsageCounts)) || ((a->pUsageCounts) && (b->pUsageCounts)))) {
+        onFail("a->pUsageCounts (Error: Mismatch in optional field)");
+    };
+    if (a->pUsageCounts && b->pUsageCounts) {
+        if ((a->pUsageCounts) && (b->pUsageCounts)) {
+            if (!((a->usageCountsCount) == (b->usageCountsCount))) {
+                onFail("a->pUsageCounts (Error: Lengths not equal)");
+            };
+            if ((a->usageCountsCount) == (b->usageCountsCount)) {
+                if (a) {
+                    for (uint32_t i = 0; i < (uint32_t)a->usageCountsCount; ++i) {
+                        checkEqual_VkMicromapUsageEXT(a->pUsageCounts + i, b->pUsageCounts + i,
+                                                      onFail);
+                    }
+                }
+            }
+        }
+    }
+    checkEqual_VkDeviceOrHostAddressConstKHR(&a->data, &b->data, onFail);
+    checkEqual_VkDeviceOrHostAddressKHR(&a->scratchData, &b->scratchData, onFail);
+    checkEqual_VkDeviceOrHostAddressConstKHR(&a->triangleArray, &b->triangleArray, onFail);
+    if (!((a->triangleArrayStride) == (b->triangleArrayStride))) {
+        onFail("a->triangleArrayStride (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkMicromapCreateInfoEXT(const VkMicromapCreateInfoEXT* a,
+                                        const VkMicromapCreateInfoEXT* b,
+                                        OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->createFlags) == (b->createFlags))) {
+        onFail("a->createFlags (Error: Value not equal)");
+    };
+    if (!((a->buffer) == (b->buffer))) {
+        onFail("a->buffer (Error: Value not equal)");
+    };
+    if (!((a->offset) == (b->offset))) {
+        onFail("a->offset (Error: Value not equal)");
+    };
+    if (!((a->size) == (b->size))) {
+        onFail("a->size (Error: Value not equal)");
+    };
+    if (!((a->type) == (b->type))) {
+        onFail("a->type (Error: Value not equal)");
+    };
+    if (!((a->deviceAddress) == (b->deviceAddress))) {
+        onFail("a->deviceAddress (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    const VkPhysicalDeviceOpacityMicromapFeaturesEXT* a,
+    const VkPhysicalDeviceOpacityMicromapFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->micromap) == (b->micromap))) {
+        onFail("a->micromap (Error: Value not equal)");
+    };
+    if (!((a->micromapCaptureReplay) == (b->micromapCaptureReplay))) {
+        onFail("a->micromapCaptureReplay (Error: Value not equal)");
+    };
+    if (!((a->micromapHostCommands) == (b->micromapHostCommands))) {
+        onFail("a->micromapHostCommands (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    const VkPhysicalDeviceOpacityMicromapPropertiesEXT* a,
+    const VkPhysicalDeviceOpacityMicromapPropertiesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->maxOpacity2StateSubdivisionLevel) == (b->maxOpacity2StateSubdivisionLevel))) {
+        onFail("a->maxOpacity2StateSubdivisionLevel (Error: Value not equal)");
+    };
+    if (!((a->maxOpacity4StateSubdivisionLevel) == (b->maxOpacity4StateSubdivisionLevel))) {
+        onFail("a->maxOpacity4StateSubdivisionLevel (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkMicromapVersionInfoEXT(const VkMicromapVersionInfoEXT* a,
+                                         const VkMicromapVersionInfoEXT* b,
+                                         OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((2 * VK_UUID_SIZE) == (2 * VK_UUID_SIZE))) {
+        onFail("a->pVersionData (Error: Lengths not equal)");
+    };
+    if (!((memcmp(a->pVersionData, b->pVersionData, 2 * VK_UUID_SIZE * sizeof(const uint8_t)) ==
+           0))) {
+        onFail("a->pVersionData (Error: Unequal dyn array)");
+    };
+}
+
+void checkEqual_VkCopyMicromapToMemoryInfoEXT(const VkCopyMicromapToMemoryInfoEXT* a,
+                                              const VkCopyMicromapToMemoryInfoEXT* b,
+                                              OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->src) == (b->src))) {
+        onFail("a->src (Error: Value not equal)");
+    };
+    checkEqual_VkDeviceOrHostAddressKHR(&a->dst, &b->dst, onFail);
+    if (!((a->mode) == (b->mode))) {
+        onFail("a->mode (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkCopyMemoryToMicromapInfoEXT(const VkCopyMemoryToMicromapInfoEXT* a,
+                                              const VkCopyMemoryToMicromapInfoEXT* b,
+                                              OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    checkEqual_VkDeviceOrHostAddressConstKHR(&a->src, &b->src, onFail);
+    if (!((a->dst) == (b->dst))) {
+        onFail("a->dst (Error: Value not equal)");
+    };
+    if (!((a->mode) == (b->mode))) {
+        onFail("a->mode (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkCopyMicromapInfoEXT(const VkCopyMicromapInfoEXT* a,
+                                      const VkCopyMicromapInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->src) == (b->src))) {
+        onFail("a->src (Error: Value not equal)");
+    };
+    if (!((a->dst) == (b->dst))) {
+        onFail("a->dst (Error: Value not equal)");
+    };
+    if (!((a->mode) == (b->mode))) {
+        onFail("a->mode (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkMicromapBuildSizesInfoEXT(const VkMicromapBuildSizesInfoEXT* a,
+                                            const VkMicromapBuildSizesInfoEXT* b,
+                                            OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->micromapSize) == (b->micromapSize))) {
+        onFail("a->micromapSize (Error: Value not equal)");
+    };
+    if (!((a->buildScratchSize) == (b->buildScratchSize))) {
+        onFail("a->buildScratchSize (Error: Value not equal)");
+    };
+    if (!((a->discardable) == (b->discardable))) {
+        onFail("a->discardable (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    const VkAccelerationStructureTrianglesOpacityMicromapEXT* a,
+    const VkAccelerationStructureTrianglesOpacityMicromapEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->indexType) == (b->indexType))) {
+        onFail("a->indexType (Error: Value not equal)");
+    };
+    checkEqual_VkDeviceOrHostAddressConstKHR(&a->indexBuffer, &b->indexBuffer, onFail);
+    if (!((a->indexStride) == (b->indexStride))) {
+        onFail("a->indexStride (Error: Value not equal)");
+    };
+    if (!((a->baseTriangle) == (b->baseTriangle))) {
+        onFail("a->baseTriangle (Error: Value not equal)");
+    };
+    if (!((a->usageCountsCount) == (b->usageCountsCount))) {
+        onFail("a->usageCountsCount (Error: Value not equal)");
+    };
+    if (!((!(a->pUsageCounts) && !(b->pUsageCounts)) || ((a->pUsageCounts) && (b->pUsageCounts)))) {
+        onFail("a->pUsageCounts (Error: Mismatch in optional field)");
+    };
+    if (a->pUsageCounts && b->pUsageCounts) {
+        if ((a->pUsageCounts) && (b->pUsageCounts)) {
+            if (!((a->usageCountsCount) == (b->usageCountsCount))) {
+                onFail("a->pUsageCounts (Error: Lengths not equal)");
+            };
+            if ((a->usageCountsCount) == (b->usageCountsCount)) {
+                if (a) {
+                    for (uint32_t i = 0; i < (uint32_t)a->usageCountsCount; ++i) {
+                        checkEqual_VkMicromapUsageEXT(a->pUsageCounts + i, b->pUsageCounts + i,
+                                                      onFail);
+                    }
+                }
+            }
+        }
+    }
+    if (!((a->micromap) == (b->micromap))) {
+        onFail("a->micromap (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkMicromapTriangleEXT(const VkMicromapTriangleEXT* a,
+                                      const VkMicromapTriangleEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->dataOffset) == (b->dataOffset))) {
+        onFail("a->dataOffset (Error: Value not equal)");
+    };
+    if (!((a->subdivisionLevel) == (b->subdivisionLevel))) {
+        onFail("a->subdivisionLevel (Error: Value not equal)");
+    };
+    if (!((a->format) == (b->format))) {
+        onFail("a->format (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_NV_displacement_micromap
+void checkEqual_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* a,
+    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->displacementMicromap) == (b->displacementMicromap))) {
+        onFail("a->displacementMicromap (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* a,
+    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->maxDisplacementMicromapSubdivisionLevel) ==
+          (b->maxDisplacementMicromapSubdivisionLevel))) {
+        onFail("a->maxDisplacementMicromapSubdivisionLevel (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    const VkAccelerationStructureTrianglesDisplacementMicromapNV* a,
+    const VkAccelerationStructureTrianglesDisplacementMicromapNV* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->displacementBiasAndScaleFormat) == (b->displacementBiasAndScaleFormat))) {
+        onFail("a->displacementBiasAndScaleFormat (Error: Value not equal)");
+    };
+    if (!((a->displacementVectorFormat) == (b->displacementVectorFormat))) {
+        onFail("a->displacementVectorFormat (Error: Value not equal)");
+    };
+    checkEqual_VkDeviceOrHostAddressConstKHR(&a->displacementBiasAndScaleBuffer,
+                                             &b->displacementBiasAndScaleBuffer, onFail);
+    if (!((a->displacementBiasAndScaleStride) == (b->displacementBiasAndScaleStride))) {
+        onFail("a->displacementBiasAndScaleStride (Error: Value not equal)");
+    };
+    checkEqual_VkDeviceOrHostAddressConstKHR(&a->displacementVectorBuffer,
+                                             &b->displacementVectorBuffer, onFail);
+    if (!((a->displacementVectorStride) == (b->displacementVectorStride))) {
+        onFail("a->displacementVectorStride (Error: Value not equal)");
+    };
+    checkEqual_VkDeviceOrHostAddressConstKHR(&a->displacedMicromapPrimitiveFlags,
+                                             &b->displacedMicromapPrimitiveFlags, onFail);
+    if (!((a->displacedMicromapPrimitiveFlagsStride) ==
+          (b->displacedMicromapPrimitiveFlagsStride))) {
+        onFail("a->displacedMicromapPrimitiveFlagsStride (Error: Value not equal)");
+    };
+    if (!((a->indexType) == (b->indexType))) {
+        onFail("a->indexType (Error: Value not equal)");
+    };
+    checkEqual_VkDeviceOrHostAddressConstKHR(&a->indexBuffer, &b->indexBuffer, onFail);
+    if (!((a->indexStride) == (b->indexStride))) {
+        onFail("a->indexStride (Error: Value not equal)");
+    };
+    if (!((a->baseTriangle) == (b->baseTriangle))) {
+        onFail("a->baseTriangle (Error: Value not equal)");
+    };
+    if (!((a->usageCountsCount) == (b->usageCountsCount))) {
+        onFail("a->usageCountsCount (Error: Value not equal)");
+    };
+    if (!((!(a->pUsageCounts) && !(b->pUsageCounts)) || ((a->pUsageCounts) && (b->pUsageCounts)))) {
+        onFail("a->pUsageCounts (Error: Mismatch in optional field)");
+    };
+    if (a->pUsageCounts && b->pUsageCounts) {
+        if ((a->pUsageCounts) && (b->pUsageCounts)) {
+            if (!((a->usageCountsCount) == (b->usageCountsCount))) {
+                onFail("a->pUsageCounts (Error: Lengths not equal)");
+            };
+            if ((a->usageCountsCount) == (b->usageCountsCount)) {
+                if (a) {
+                    for (uint32_t i = 0; i < (uint32_t)a->usageCountsCount; ++i) {
+                        checkEqual_VkMicromapUsageEXT(a->pUsageCounts + i, b->pUsageCounts + i,
+                                                      onFail);
+                    }
+                }
+            }
+        }
+    }
+    if (!((a->micromap) == (b->micromap))) {
+        onFail("a->micromap (Error: Value not equal)");
+    };
+}
+
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void checkEqual_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* a,
+    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->clustercullingShader) == (b->clustercullingShader))) {
+        onFail("a->clustercullingShader (Error: Value not equal)");
+    };
+    if (!((a->multiviewClusterCullingShader) == (b->multiviewClusterCullingShader))) {
+        onFail("a->multiviewClusterCullingShader (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* a,
+    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((memcmp(a->maxWorkGroupCount, b->maxWorkGroupCount, 3 * sizeof(uint32_t)) == 0))) {
+        onFail("a->maxWorkGroupCount (Error: Unequal static array)");
+    };
+    if (!((memcmp(a->maxWorkGroupSize, b->maxWorkGroupSize, 3 * sizeof(uint32_t)) == 0))) {
+        onFail("a->maxWorkGroupSize (Error: Unequal static array)");
+    };
+    if (!((a->maxOutputClusterCount) == (b->maxOutputClusterCount))) {
+        onFail("a->maxOutputClusterCount (Error: Value not equal)");
+    };
+    if (!((a->indirectBufferOffsetAlignment) == (b->indirectBufferOffsetAlignment))) {
+        onFail("a->indirectBufferOffsetAlignment (Error: Value not equal)");
+    };
+}
+
+#endif
 #ifdef VK_EXT_border_color_swizzle
 void checkEqual_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
     const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* a,
@@ -17306,18 +19771,1340 @@ void checkEqual_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
 }
 
 #endif
-#ifdef VK_KHR_acceleration_structure
-void checkEqual_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* a,
-                                         const VkDeviceOrHostAddressKHR* b,
-                                         OnFailCompareFunc onFail) {
-    if (!((a->deviceAddress) == (b->deviceAddress))) {
-        onFail("a->deviceAddress (Error: Value not equal)");
+#ifdef VK_ARM_shader_core_properties
+void checkEqual_VkPhysicalDeviceShaderCorePropertiesARM(
+    const VkPhysicalDeviceShaderCorePropertiesARM* a,
+    const VkPhysicalDeviceShaderCorePropertiesARM* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
     };
-    if (!((!(a->hostAddress) && !(b->hostAddress)) || ((a->hostAddress) && (b->hostAddress)))) {
-        onFail("a->hostAddress (Error: Mismatch in optional field)");
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->pixelRate) == (b->pixelRate))) {
+        onFail("a->pixelRate (Error: Value not equal)");
+    };
+    if (!((a->texelRate) == (b->texelRate))) {
+        onFail("a->texelRate (Error: Value not equal)");
+    };
+    if (!((a->fmaRate) == (b->fmaRate))) {
+        onFail("a->fmaRate (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+void checkEqual_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* a,
+    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->imageSlicedViewOf3D) == (b->imageSlicedViewOf3D))) {
+        onFail("a->imageSlicedViewOf3D (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkImageViewSlicedCreateInfoEXT(const VkImageViewSlicedCreateInfoEXT* a,
+                                               const VkImageViewSlicedCreateInfoEXT* b,
+                                               OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->sliceOffset) == (b->sliceOffset))) {
+        onFail("a->sliceOffset (Error: Value not equal)");
+    };
+    if (!((a->sliceCount) == (b->sliceCount))) {
+        onFail("a->sliceCount (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void checkEqual_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* a,
+    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->descriptorSetHostMapping) == (b->descriptorSetHostMapping))) {
+        onFail("a->descriptorSetHostMapping (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDescriptorSetBindingReferenceVALVE(const VkDescriptorSetBindingReferenceVALVE* a,
+                                                     const VkDescriptorSetBindingReferenceVALVE* b,
+                                                     OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->descriptorSetLayout) == (b->descriptorSetLayout))) {
+        onFail("a->descriptorSetLayout (Error: Value not equal)");
+    };
+    if (!((a->binding) == (b->binding))) {
+        onFail("a->binding (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    const VkDescriptorSetLayoutHostMappingInfoVALVE* a,
+    const VkDescriptorSetLayoutHostMappingInfoVALVE* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->descriptorOffset) == (b->descriptorOffset))) {
+        onFail("a->descriptorOffset (Error: Value not equal)");
+    };
+    if (!((a->descriptorSize) == (b->descriptorSize))) {
+        onFail("a->descriptorSize (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+void checkEqual_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* a,
+    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->depthClampZeroOne) == (b->depthClampZeroOne))) {
+        onFail("a->depthClampZeroOne (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+void checkEqual_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* a,
+    const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->nonSeamlessCubeMap) == (b->nonSeamlessCubeMap))) {
+        onFail("a->nonSeamlessCubeMap (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+void checkEqual_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* a,
+    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->fragmentDensityMapOffset) == (b->fragmentDensityMapOffset))) {
+        onFail("a->fragmentDensityMapOffset (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* a,
+    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    checkEqual_VkExtent2D(&a->fragmentDensityOffsetGranularity,
+                          &b->fragmentDensityOffsetGranularity, onFail);
+}
+
+void checkEqual_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* a,
+    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->fragmentDensityOffsetCount) == (b->fragmentDensityOffsetCount))) {
+        onFail("a->fragmentDensityOffsetCount (Error: Value not equal)");
+    };
+    if ((a->pFragmentDensityOffsets) && (b->pFragmentDensityOffsets)) {
+        if (!((a->fragmentDensityOffsetCount) == (b->fragmentDensityOffsetCount))) {
+            onFail("a->pFragmentDensityOffsets (Error: Lengths not equal)");
+        };
+        if ((a->fragmentDensityOffsetCount) == (b->fragmentDensityOffsetCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->fragmentDensityOffsetCount; ++i) {
+                    checkEqual_VkOffset2D(a->pFragmentDensityOffsets + i,
+                                          b->pFragmentDensityOffsets + i, onFail);
+                }
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void checkEqual_VkCopyMemoryIndirectCommandNV(const VkCopyMemoryIndirectCommandNV* a,
+                                              const VkCopyMemoryIndirectCommandNV* b,
+                                              OnFailCompareFunc onFail) {
+    if (!((a->srcAddress) == (b->srcAddress))) {
+        onFail("a->srcAddress (Error: Value not equal)");
+    };
+    if (!((a->dstAddress) == (b->dstAddress))) {
+        onFail("a->dstAddress (Error: Value not equal)");
+    };
+    if (!((a->size) == (b->size))) {
+        onFail("a->size (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkCopyMemoryToImageIndirectCommandNV(const VkCopyMemoryToImageIndirectCommandNV* a,
+                                                     const VkCopyMemoryToImageIndirectCommandNV* b,
+                                                     OnFailCompareFunc onFail) {
+    if (!((a->srcAddress) == (b->srcAddress))) {
+        onFail("a->srcAddress (Error: Value not equal)");
+    };
+    if (!((a->bufferRowLength) == (b->bufferRowLength))) {
+        onFail("a->bufferRowLength (Error: Value not equal)");
+    };
+    if (!((a->bufferImageHeight) == (b->bufferImageHeight))) {
+        onFail("a->bufferImageHeight (Error: Value not equal)");
+    };
+    checkEqual_VkImageSubresourceLayers(&a->imageSubresource, &b->imageSubresource, onFail);
+    checkEqual_VkOffset3D(&a->imageOffset, &b->imageOffset, onFail);
+    checkEqual_VkExtent3D(&a->imageExtent, &b->imageExtent, onFail);
+}
+
+void checkEqual_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* a,
+    const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->indirectCopy) == (b->indirectCopy))) {
+        onFail("a->indirectCopy (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* a,
+    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->supportedQueues) == (b->supportedQueues))) {
+        onFail("a->supportedQueues (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_NV_memory_decompression
+void checkEqual_VkDecompressMemoryRegionNV(const VkDecompressMemoryRegionNV* a,
+                                           const VkDecompressMemoryRegionNV* b,
+                                           OnFailCompareFunc onFail) {
+    if (!((a->srcAddress) == (b->srcAddress))) {
+        onFail("a->srcAddress (Error: Value not equal)");
+    };
+    if (!((a->dstAddress) == (b->dstAddress))) {
+        onFail("a->dstAddress (Error: Value not equal)");
+    };
+    if (!((a->compressedSize) == (b->compressedSize))) {
+        onFail("a->compressedSize (Error: Value not equal)");
+    };
+    if (!((a->decompressedSize) == (b->decompressedSize))) {
+        onFail("a->decompressedSize (Error: Value not equal)");
+    };
+    if (!((a->decompressionMethod) == (b->decompressionMethod))) {
+        onFail("a->decompressionMethod (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    const VkPhysicalDeviceMemoryDecompressionFeaturesNV* a,
+    const VkPhysicalDeviceMemoryDecompressionFeaturesNV* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->memoryDecompression) == (b->memoryDecompression))) {
+        onFail("a->memoryDecompression (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* a,
+    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->decompressionMethods) == (b->decompressionMethods))) {
+        onFail("a->decompressionMethods (Error: Value not equal)");
+    };
+    if (!((a->maxDecompressionIndirectCount) == (b->maxDecompressionIndirectCount))) {
+        onFail("a->maxDecompressionIndirectCount (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_NV_linear_color_attachment
+void checkEqual_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* a,
+    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->linearColorAttachment) == (b->linearColorAttachment))) {
+        onFail("a->linearColorAttachment (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+void checkEqual_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* a,
+    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* b,
+    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->imageCompressionControlSwapchain) == (b->imageCompressionControlSwapchain))) {
+        onFail("a->imageCompressionControlSwapchain (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_QCOM_image_processing
+void checkEqual_VkImageViewSampleWeightCreateInfoQCOM(
+    const VkImageViewSampleWeightCreateInfoQCOM* a, const VkImageViewSampleWeightCreateInfoQCOM* b,
+    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    checkEqual_VkOffset2D(&a->filterCenter, &b->filterCenter, onFail);
+    checkEqual_VkExtent2D(&a->filterSize, &b->filterSize, onFail);
+    if (!((a->numPhases) == (b->numPhases))) {
+        onFail("a->numPhases (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    const VkPhysicalDeviceImageProcessingFeaturesQCOM* a,
+    const VkPhysicalDeviceImageProcessingFeaturesQCOM* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->textureSampleWeighted) == (b->textureSampleWeighted))) {
+        onFail("a->textureSampleWeighted (Error: Value not equal)");
+    };
+    if (!((a->textureBoxFilter) == (b->textureBoxFilter))) {
+        onFail("a->textureBoxFilter (Error: Value not equal)");
+    };
+    if (!((a->textureBlockMatch) == (b->textureBlockMatch))) {
+        onFail("a->textureBlockMatch (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    const VkPhysicalDeviceImageProcessingPropertiesQCOM* a,
+    const VkPhysicalDeviceImageProcessingPropertiesQCOM* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->maxWeightFilterPhases) == (b->maxWeightFilterPhases))) {
+        onFail("a->maxWeightFilterPhases (Error: Value not equal)");
+    };
+    checkEqual_VkExtent2D(&a->maxWeightFilterDimension, &b->maxWeightFilterDimension, onFail);
+    checkEqual_VkExtent2D(&a->maxBlockMatchRegion, &b->maxBlockMatchRegion, onFail);
+    checkEqual_VkExtent2D(&a->maxBoxFilterBlockSize, &b->maxBoxFilterBlockSize, onFail);
+}
+
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void checkEqual_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* a,
+    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->extendedDynamicState3TessellationDomainOrigin) ==
+          (b->extendedDynamicState3TessellationDomainOrigin))) {
+        onFail("a->extendedDynamicState3TessellationDomainOrigin (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3DepthClampEnable) ==
+          (b->extendedDynamicState3DepthClampEnable))) {
+        onFail("a->extendedDynamicState3DepthClampEnable (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3PolygonMode) == (b->extendedDynamicState3PolygonMode))) {
+        onFail("a->extendedDynamicState3PolygonMode (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3RasterizationSamples) ==
+          (b->extendedDynamicState3RasterizationSamples))) {
+        onFail("a->extendedDynamicState3RasterizationSamples (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3SampleMask) == (b->extendedDynamicState3SampleMask))) {
+        onFail("a->extendedDynamicState3SampleMask (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3AlphaToCoverageEnable) ==
+          (b->extendedDynamicState3AlphaToCoverageEnable))) {
+        onFail("a->extendedDynamicState3AlphaToCoverageEnable (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3AlphaToOneEnable) ==
+          (b->extendedDynamicState3AlphaToOneEnable))) {
+        onFail("a->extendedDynamicState3AlphaToOneEnable (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3LogicOpEnable) == (b->extendedDynamicState3LogicOpEnable))) {
+        onFail("a->extendedDynamicState3LogicOpEnable (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3ColorBlendEnable) ==
+          (b->extendedDynamicState3ColorBlendEnable))) {
+        onFail("a->extendedDynamicState3ColorBlendEnable (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3ColorBlendEquation) ==
+          (b->extendedDynamicState3ColorBlendEquation))) {
+        onFail("a->extendedDynamicState3ColorBlendEquation (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3ColorWriteMask) == (b->extendedDynamicState3ColorWriteMask))) {
+        onFail("a->extendedDynamicState3ColorWriteMask (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3RasterizationStream) ==
+          (b->extendedDynamicState3RasterizationStream))) {
+        onFail("a->extendedDynamicState3RasterizationStream (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3ConservativeRasterizationMode) ==
+          (b->extendedDynamicState3ConservativeRasterizationMode))) {
+        onFail("a->extendedDynamicState3ConservativeRasterizationMode (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3ExtraPrimitiveOverestimationSize) ==
+          (b->extendedDynamicState3ExtraPrimitiveOverestimationSize))) {
+        onFail("a->extendedDynamicState3ExtraPrimitiveOverestimationSize (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3DepthClipEnable) == (b->extendedDynamicState3DepthClipEnable))) {
+        onFail("a->extendedDynamicState3DepthClipEnable (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3SampleLocationsEnable) ==
+          (b->extendedDynamicState3SampleLocationsEnable))) {
+        onFail("a->extendedDynamicState3SampleLocationsEnable (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3ColorBlendAdvanced) ==
+          (b->extendedDynamicState3ColorBlendAdvanced))) {
+        onFail("a->extendedDynamicState3ColorBlendAdvanced (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3ProvokingVertexMode) ==
+          (b->extendedDynamicState3ProvokingVertexMode))) {
+        onFail("a->extendedDynamicState3ProvokingVertexMode (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3LineRasterizationMode) ==
+          (b->extendedDynamicState3LineRasterizationMode))) {
+        onFail("a->extendedDynamicState3LineRasterizationMode (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3LineStippleEnable) ==
+          (b->extendedDynamicState3LineStippleEnable))) {
+        onFail("a->extendedDynamicState3LineStippleEnable (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3DepthClipNegativeOneToOne) ==
+          (b->extendedDynamicState3DepthClipNegativeOneToOne))) {
+        onFail("a->extendedDynamicState3DepthClipNegativeOneToOne (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3ViewportWScalingEnable) ==
+          (b->extendedDynamicState3ViewportWScalingEnable))) {
+        onFail("a->extendedDynamicState3ViewportWScalingEnable (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3ViewportSwizzle) == (b->extendedDynamicState3ViewportSwizzle))) {
+        onFail("a->extendedDynamicState3ViewportSwizzle (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3CoverageToColorEnable) ==
+          (b->extendedDynamicState3CoverageToColorEnable))) {
+        onFail("a->extendedDynamicState3CoverageToColorEnable (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3CoverageToColorLocation) ==
+          (b->extendedDynamicState3CoverageToColorLocation))) {
+        onFail("a->extendedDynamicState3CoverageToColorLocation (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3CoverageModulationMode) ==
+          (b->extendedDynamicState3CoverageModulationMode))) {
+        onFail("a->extendedDynamicState3CoverageModulationMode (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3CoverageModulationTableEnable) ==
+          (b->extendedDynamicState3CoverageModulationTableEnable))) {
+        onFail("a->extendedDynamicState3CoverageModulationTableEnable (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3CoverageModulationTable) ==
+          (b->extendedDynamicState3CoverageModulationTable))) {
+        onFail("a->extendedDynamicState3CoverageModulationTable (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3CoverageReductionMode) ==
+          (b->extendedDynamicState3CoverageReductionMode))) {
+        onFail("a->extendedDynamicState3CoverageReductionMode (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3RepresentativeFragmentTestEnable) ==
+          (b->extendedDynamicState3RepresentativeFragmentTestEnable))) {
+        onFail("a->extendedDynamicState3RepresentativeFragmentTestEnable (Error: Value not equal)");
+    };
+    if (!((a->extendedDynamicState3ShadingRateImageEnable) ==
+          (b->extendedDynamicState3ShadingRateImageEnable))) {
+        onFail("a->extendedDynamicState3ShadingRateImageEnable (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* a,
+    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->dynamicPrimitiveTopologyUnrestricted) == (b->dynamicPrimitiveTopologyUnrestricted))) {
+        onFail("a->dynamicPrimitiveTopologyUnrestricted (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkColorBlendEquationEXT(const VkColorBlendEquationEXT* a,
+                                        const VkColorBlendEquationEXT* b,
+                                        OnFailCompareFunc onFail) {
+    if (!((a->srcColorBlendFactor) == (b->srcColorBlendFactor))) {
+        onFail("a->srcColorBlendFactor (Error: Value not equal)");
+    };
+    if (!((a->dstColorBlendFactor) == (b->dstColorBlendFactor))) {
+        onFail("a->dstColorBlendFactor (Error: Value not equal)");
+    };
+    if (!((a->colorBlendOp) == (b->colorBlendOp))) {
+        onFail("a->colorBlendOp (Error: Value not equal)");
+    };
+    if (!((a->srcAlphaBlendFactor) == (b->srcAlphaBlendFactor))) {
+        onFail("a->srcAlphaBlendFactor (Error: Value not equal)");
+    };
+    if (!((a->dstAlphaBlendFactor) == (b->dstAlphaBlendFactor))) {
+        onFail("a->dstAlphaBlendFactor (Error: Value not equal)");
+    };
+    if (!((a->alphaBlendOp) == (b->alphaBlendOp))) {
+        onFail("a->alphaBlendOp (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkColorBlendAdvancedEXT(const VkColorBlendAdvancedEXT* a,
+                                        const VkColorBlendAdvancedEXT* b,
+                                        OnFailCompareFunc onFail) {
+    if (!((a->advancedBlendOp) == (b->advancedBlendOp))) {
+        onFail("a->advancedBlendOp (Error: Value not equal)");
+    };
+    if (!((a->srcPremultiplied) == (b->srcPremultiplied))) {
+        onFail("a->srcPremultiplied (Error: Value not equal)");
+    };
+    if (!((a->dstPremultiplied) == (b->dstPremultiplied))) {
+        onFail("a->dstPremultiplied (Error: Value not equal)");
+    };
+    if (!((a->blendOverlap) == (b->blendOverlap))) {
+        onFail("a->blendOverlap (Error: Value not equal)");
+    };
+    if (!((a->clampResults) == (b->clampResults))) {
+        onFail("a->clampResults (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+void checkEqual_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* a,
+    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->subpassMergeFeedback) == (b->subpassMergeFeedback))) {
+        onFail("a->subpassMergeFeedback (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkRenderPassCreationControlEXT(const VkRenderPassCreationControlEXT* a,
+                                               const VkRenderPassCreationControlEXT* b,
+                                               OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->disallowMerging) == (b->disallowMerging))) {
+        onFail("a->disallowMerging (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkRenderPassCreationFeedbackInfoEXT(const VkRenderPassCreationFeedbackInfoEXT* a,
+                                                    const VkRenderPassCreationFeedbackInfoEXT* b,
+                                                    OnFailCompareFunc onFail) {
+    if (!((a->postMergeSubpassCount) == (b->postMergeSubpassCount))) {
+        onFail("a->postMergeSubpassCount (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkRenderPassCreationFeedbackCreateInfoEXT(
+    const VkRenderPassCreationFeedbackCreateInfoEXT* a,
+    const VkRenderPassCreationFeedbackCreateInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if ((a->pRenderPassFeedback) && (b->pRenderPassFeedback)) {
+        checkEqual_VkRenderPassCreationFeedbackInfoEXT(a->pRenderPassFeedback,
+                                                       b->pRenderPassFeedback, onFail);
+    }
+}
+
+void checkEqual_VkRenderPassSubpassFeedbackInfoEXT(const VkRenderPassSubpassFeedbackInfoEXT* a,
+                                                   const VkRenderPassSubpassFeedbackInfoEXT* b,
+                                                   OnFailCompareFunc onFail) {
+    if (!((a->subpassMergeStatus) == (b->subpassMergeStatus))) {
+        onFail("a->subpassMergeStatus (Error: Value not equal)");
+    };
+    if (!((memcmp(a->description, b->description, VK_MAX_DESCRIPTION_SIZE * sizeof(char)) == 0))) {
+        onFail("a->description (Error: Unequal static array)");
+    };
+    if (!((a->postMergeIndex) == (b->postMergeIndex))) {
+        onFail("a->postMergeIndex (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    const VkRenderPassSubpassFeedbackCreateInfoEXT* a,
+    const VkRenderPassSubpassFeedbackCreateInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if ((a->pSubpassFeedback) && (b->pSubpassFeedback)) {
+        checkEqual_VkRenderPassSubpassFeedbackInfoEXT(a->pSubpassFeedback, b->pSubpassFeedback,
+                                                      onFail);
+    }
+}
+
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+void checkEqual_VkDirectDriverLoadingInfoLUNARG(const VkDirectDriverLoadingInfoLUNARG* a,
+                                                const VkDirectDriverLoadingInfoLUNARG* b,
+                                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+    if (!((a->pfnGetInstanceProcAddr) == (b->pfnGetInstanceProcAddr))) {
+        onFail("a->pfnGetInstanceProcAddr (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDirectDriverLoadingListLUNARG(const VkDirectDriverLoadingListLUNARG* a,
+                                                const VkDirectDriverLoadingListLUNARG* b,
+                                                OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->mode) == (b->mode))) {
+        onFail("a->mode (Error: Value not equal)");
+    };
+    if (!((a->driverCount) == (b->driverCount))) {
+        onFail("a->driverCount (Error: Value not equal)");
+    };
+    if ((a->pDrivers) && (b->pDrivers)) {
+        if (!((a->driverCount) == (b->driverCount))) {
+            onFail("a->pDrivers (Error: Lengths not equal)");
+        };
+        if ((a->driverCount) == (b->driverCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->driverCount; ++i) {
+                    checkEqual_VkDirectDriverLoadingInfoLUNARG(a->pDrivers + i, b->pDrivers + i,
+                                                               onFail);
+                }
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void checkEqual_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* a,
+    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->shaderModuleIdentifier) == (b->shaderModuleIdentifier))) {
+        onFail("a->shaderModuleIdentifier (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* a,
+    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((memcmp(a->shaderModuleIdentifierAlgorithmUUID, b->shaderModuleIdentifierAlgorithmUUID,
+                  VK_UUID_SIZE * sizeof(uint8_t)) == 0))) {
+        onFail("a->shaderModuleIdentifierAlgorithmUUID (Error: Unequal static array)");
+    };
+}
+
+void checkEqual_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* a,
+    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->identifierSize) == (b->identifierSize))) {
+        onFail("a->identifierSize (Error: Value not equal)");
+    };
+    if (!((a->identifierSize) == (b->identifierSize))) {
+        onFail("a->pIdentifier (Error: Lengths not equal)");
+    };
+    if (!((memcmp(a->pIdentifier, b->pIdentifier, a->identifierSize * sizeof(const uint8_t)) ==
+           0))) {
+        onFail("a->pIdentifier (Error: Unequal dyn array)");
+    };
+}
+
+void checkEqual_VkShaderModuleIdentifierEXT(const VkShaderModuleIdentifierEXT* a,
+                                            const VkShaderModuleIdentifierEXT* b,
+                                            OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->identifierSize) == (b->identifierSize))) {
+        onFail("a->identifierSize (Error: Value not equal)");
+    };
+    if (!((memcmp(a->identifier, b->identifier,
+                  VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT * sizeof(uint8_t)) == 0))) {
+        onFail("a->identifier (Error: Unequal static array)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+void checkEqual_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    const VkPhysicalDeviceOpticalFlowFeaturesNV* a, const VkPhysicalDeviceOpticalFlowFeaturesNV* b,
+    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->opticalFlow) == (b->opticalFlow))) {
+        onFail("a->opticalFlow (Error: Value not equal)");
     };
 }
 
+void checkEqual_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    const VkPhysicalDeviceOpticalFlowPropertiesNV* a,
+    const VkPhysicalDeviceOpticalFlowPropertiesNV* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->supportedOutputGridSizes) == (b->supportedOutputGridSizes))) {
+        onFail("a->supportedOutputGridSizes (Error: Value not equal)");
+    };
+    if (!((a->supportedHintGridSizes) == (b->supportedHintGridSizes))) {
+        onFail("a->supportedHintGridSizes (Error: Value not equal)");
+    };
+    if (!((a->hintSupported) == (b->hintSupported))) {
+        onFail("a->hintSupported (Error: Value not equal)");
+    };
+    if (!((a->costSupported) == (b->costSupported))) {
+        onFail("a->costSupported (Error: Value not equal)");
+    };
+    if (!((a->bidirectionalFlowSupported) == (b->bidirectionalFlowSupported))) {
+        onFail("a->bidirectionalFlowSupported (Error: Value not equal)");
+    };
+    if (!((a->globalFlowSupported) == (b->globalFlowSupported))) {
+        onFail("a->globalFlowSupported (Error: Value not equal)");
+    };
+    if (!((a->minWidth) == (b->minWidth))) {
+        onFail("a->minWidth (Error: Value not equal)");
+    };
+    if (!((a->minHeight) == (b->minHeight))) {
+        onFail("a->minHeight (Error: Value not equal)");
+    };
+    if (!((a->maxWidth) == (b->maxWidth))) {
+        onFail("a->maxWidth (Error: Value not equal)");
+    };
+    if (!((a->maxHeight) == (b->maxHeight))) {
+        onFail("a->maxHeight (Error: Value not equal)");
+    };
+    if (!((a->maxNumRegionsOfInterest) == (b->maxNumRegionsOfInterest))) {
+        onFail("a->maxNumRegionsOfInterest (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkOpticalFlowImageFormatInfoNV(const VkOpticalFlowImageFormatInfoNV* a,
+                                               const VkOpticalFlowImageFormatInfoNV* b,
+                                               OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->usage) == (b->usage))) {
+        onFail("a->usage (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkOpticalFlowImageFormatPropertiesNV(const VkOpticalFlowImageFormatPropertiesNV* a,
+                                                     const VkOpticalFlowImageFormatPropertiesNV* b,
+                                                     OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->format) == (b->format))) {
+        onFail("a->format (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkOpticalFlowSessionCreateInfoNV(const VkOpticalFlowSessionCreateInfoNV* a,
+                                                 const VkOpticalFlowSessionCreateInfoNV* b,
+                                                 OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->width) == (b->width))) {
+        onFail("a->width (Error: Value not equal)");
+    };
+    if (!((a->height) == (b->height))) {
+        onFail("a->height (Error: Value not equal)");
+    };
+    if (!((a->imageFormat) == (b->imageFormat))) {
+        onFail("a->imageFormat (Error: Value not equal)");
+    };
+    if (!((a->flowVectorFormat) == (b->flowVectorFormat))) {
+        onFail("a->flowVectorFormat (Error: Value not equal)");
+    };
+    if (!((a->costFormat) == (b->costFormat))) {
+        onFail("a->costFormat (Error: Value not equal)");
+    };
+    if (!((a->outputGridSize) == (b->outputGridSize))) {
+        onFail("a->outputGridSize (Error: Value not equal)");
+    };
+    if (!((a->hintGridSize) == (b->hintGridSize))) {
+        onFail("a->hintGridSize (Error: Value not equal)");
+    };
+    if (!((a->performanceLevel) == (b->performanceLevel))) {
+        onFail("a->performanceLevel (Error: Value not equal)");
+    };
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    const VkOpticalFlowSessionCreatePrivateDataInfoNV* a,
+    const VkOpticalFlowSessionCreatePrivateDataInfoNV* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->id) == (b->id))) {
+        onFail("a->id (Error: Value not equal)");
+    };
+    if (!((a->size) == (b->size))) {
+        onFail("a->size (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkOpticalFlowExecuteInfoNV(const VkOpticalFlowExecuteInfoNV* a,
+                                           const VkOpticalFlowExecuteInfoNV* b,
+                                           OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+    if (!((a->regionCount) == (b->regionCount))) {
+        onFail("a->regionCount (Error: Value not equal)");
+    };
+    if ((a->pRegions) && (b->pRegions)) {
+        if (!((a->regionCount) == (b->regionCount))) {
+            onFail("a->pRegions (Error: Lengths not equal)");
+        };
+        if ((a->regionCount) == (b->regionCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->regionCount; ++i) {
+                    checkEqual_VkRect2D(a->pRegions + i, b->pRegions + i, onFail);
+                }
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_legacy_dithering
+void checkEqual_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    const VkPhysicalDeviceLegacyDitheringFeaturesEXT* a,
+    const VkPhysicalDeviceLegacyDitheringFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->legacyDithering) == (b->legacyDithering))) {
+        onFail("a->legacyDithering (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+void checkEqual_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* a,
+    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->pipelineProtectedAccess) == (b->pipelineProtectedAccess))) {
+        onFail("a->pipelineProtectedAccess (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_shader_object
+void checkEqual_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    const VkPhysicalDeviceShaderObjectFeaturesEXT* a,
+    const VkPhysicalDeviceShaderObjectFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->shaderObject) == (b->shaderObject))) {
+        onFail("a->shaderObject (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    const VkPhysicalDeviceShaderObjectPropertiesEXT* a,
+    const VkPhysicalDeviceShaderObjectPropertiesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((memcmp(a->shaderBinaryUUID, b->shaderBinaryUUID, VK_UUID_SIZE * sizeof(uint8_t)) ==
+           0))) {
+        onFail("a->shaderBinaryUUID (Error: Unequal static array)");
+    };
+    if (!((a->shaderBinaryVersion) == (b->shaderBinaryVersion))) {
+        onFail("a->shaderBinaryVersion (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkShaderCreateInfoEXT(const VkShaderCreateInfoEXT* a,
+                                      const VkShaderCreateInfoEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->flags) == (b->flags))) {
+        onFail("a->flags (Error: Value not equal)");
+    };
+    if (!((a->stage) == (b->stage))) {
+        onFail("a->stage (Error: Value not equal)");
+    };
+    if (!((a->nextStage) == (b->nextStage))) {
+        onFail("a->nextStage (Error: Value not equal)");
+    };
+    if (!((a->codeType) == (b->codeType))) {
+        onFail("a->codeType (Error: Value not equal)");
+    };
+    if (!((a->codeSize) == (b->codeSize))) {
+        onFail("a->codeSize (Error: Value not equal)");
+    };
+    if (!((!(a->pName) && !(b->pName)) || ((a->pName) && (b->pName)))) {
+        onFail("a->pName (Error: Mismatch in optional field)");
+    };
+    if (a->pName && b->pName) {
+        if (!((!(a->pName) && !(b->pName)) || ((a->pName) && (b->pName)))) {
+            onFail("a->pName (Error: Mismatch in string pointer nullness)");
+        };
+        if ((a->pName) && (b->pName)) {
+            if (!((strcmp(a->pName, b->pName) == 0))) {
+                onFail("a->pName (Error: Unequal strings)");
+            };
+        }
+    }
+    if (!((a->setLayoutCount) == (b->setLayoutCount))) {
+        onFail("a->setLayoutCount (Error: Value not equal)");
+    };
+    if (!((!(a->pSetLayouts) && !(b->pSetLayouts)) || ((a->pSetLayouts) && (b->pSetLayouts)))) {
+        onFail("a->pSetLayouts (Error: Mismatch in optional field)");
+    };
+    if (a->pSetLayouts && b->pSetLayouts) {
+        if (!((a->setLayoutCount) == (b->setLayoutCount))) {
+            onFail("a->pSetLayouts (Error: Lengths not equal)");
+        };
+        if (!((memcmp(a->pSetLayouts, b->pSetLayouts,
+                      a->setLayoutCount * sizeof(const VkDescriptorSetLayout)) == 0))) {
+            onFail("a->pSetLayouts (Error: Unequal dyn array)");
+        };
+    }
+    if (!((a->pushConstantRangeCount) == (b->pushConstantRangeCount))) {
+        onFail("a->pushConstantRangeCount (Error: Value not equal)");
+    };
+    if (!((!(a->pPushConstantRanges) && !(b->pPushConstantRanges)) ||
+          ((a->pPushConstantRanges) && (b->pPushConstantRanges)))) {
+        onFail("a->pPushConstantRanges (Error: Mismatch in optional field)");
+    };
+    if (a->pPushConstantRanges && b->pPushConstantRanges) {
+        if ((a->pPushConstantRanges) && (b->pPushConstantRanges)) {
+            if (!((a->pushConstantRangeCount) == (b->pushConstantRangeCount))) {
+                onFail("a->pPushConstantRanges (Error: Lengths not equal)");
+            };
+            if ((a->pushConstantRangeCount) == (b->pushConstantRangeCount)) {
+                if (a) {
+                    for (uint32_t i = 0; i < (uint32_t)a->pushConstantRangeCount; ++i) {
+                        checkEqual_VkPushConstantRange(a->pPushConstantRanges + i,
+                                                       b->pPushConstantRanges + i, onFail);
+                    }
+                }
+            }
+        }
+    }
+    if (!((!(a->pSpecializationInfo) && !(b->pSpecializationInfo)) ||
+          ((a->pSpecializationInfo) && (b->pSpecializationInfo)))) {
+        onFail("a->pSpecializationInfo (Error: Mismatch in optional field)");
+    };
+    if (a->pSpecializationInfo && b->pSpecializationInfo) {
+        if ((a->pSpecializationInfo) && (b->pSpecializationInfo)) {
+            checkEqual_VkSpecializationInfo(a->pSpecializationInfo, b->pSpecializationInfo, onFail);
+        }
+    }
+}
+
+#endif
+#ifdef VK_QCOM_tile_properties
+void checkEqual_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    const VkPhysicalDeviceTilePropertiesFeaturesQCOM* a,
+    const VkPhysicalDeviceTilePropertiesFeaturesQCOM* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->tileProperties) == (b->tileProperties))) {
+        onFail("a->tileProperties (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkTilePropertiesQCOM(const VkTilePropertiesQCOM* a, const VkTilePropertiesQCOM* b,
+                                     OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    checkEqual_VkExtent3D(&a->tileSize, &b->tileSize, onFail);
+    checkEqual_VkExtent2D(&a->apronSize, &b->apronSize, onFail);
+    checkEqual_VkOffset2D(&a->origin, &b->origin, onFail);
+}
+
+#endif
+#ifdef VK_SEC_amigo_profiling
+void checkEqual_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    const VkPhysicalDeviceAmigoProfilingFeaturesSEC* a,
+    const VkPhysicalDeviceAmigoProfilingFeaturesSEC* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->amigoProfiling) == (b->amigoProfiling))) {
+        onFail("a->amigoProfiling (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkAmigoProfilingSubmitInfoSEC(const VkAmigoProfilingSubmitInfoSEC* a,
+                                              const VkAmigoProfilingSubmitInfoSEC* b,
+                                              OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->firstDrawTimestamp) == (b->firstDrawTimestamp))) {
+        onFail("a->firstDrawTimestamp (Error: Value not equal)");
+    };
+    if (!((a->swapBufferTimestamp) == (b->swapBufferTimestamp))) {
+        onFail("a->swapBufferTimestamp (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+void checkEqual_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* a,
+    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->multiviewPerViewViewports) == (b->multiviewPerViewViewports))) {
+        onFail("a->multiviewPerViewViewports (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+void checkEqual_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* a,
+    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->rayTracingInvocationReorderReorderingHint) ==
+          (b->rayTracingInvocationReorderReorderingHint))) {
+        onFail("a->rayTracingInvocationReorderReorderingHint (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* a,
+    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->rayTracingInvocationReorder) == (b->rayTracingInvocationReorder))) {
+        onFail("a->rayTracingInvocationReorder (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+void checkEqual_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* a,
+    const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->shaderCoreBuiltins) == (b->shaderCoreBuiltins))) {
+        onFail("a->shaderCoreBuiltins (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* a,
+    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->shaderCoreMask) == (b->shaderCoreMask))) {
+        onFail("a->shaderCoreMask (Error: Value not equal)");
+    };
+    if (!((a->shaderCoreCount) == (b->shaderCoreCount))) {
+        onFail("a->shaderCoreCount (Error: Value not equal)");
+    };
+    if (!((a->shaderWarpsPerCore) == (b->shaderWarpsPerCore))) {
+        onFail("a->shaderWarpsPerCore (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+void checkEqual_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* a,
+    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->pipelineLibraryGroupHandles) == (b->pipelineLibraryGroupHandles))) {
+        onFail("a->pipelineLibraryGroupHandles (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+void checkEqual_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* a,
+    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->multiviewPerViewRenderAreas) == (b->multiviewPerViewRenderAreas))) {
+        onFail("a->multiviewPerViewRenderAreas (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* a,
+    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->perViewRenderAreaCount) == (b->perViewRenderAreaCount))) {
+        onFail("a->perViewRenderAreaCount (Error: Value not equal)");
+    };
+    if ((a->pPerViewRenderAreas) && (b->pPerViewRenderAreas)) {
+        if (!((a->perViewRenderAreaCount) == (b->perViewRenderAreaCount))) {
+            onFail("a->pPerViewRenderAreas (Error: Lengths not equal)");
+        };
+        if ((a->perViewRenderAreaCount) == (b->perViewRenderAreaCount)) {
+            if (a) {
+                for (uint32_t i = 0; i < (uint32_t)a->perViewRenderAreaCount; ++i) {
+                    checkEqual_VkRect2D(a->pPerViewRenderAreas + i, b->pPerViewRenderAreas + i,
+                                        onFail);
+                }
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+void checkEqual_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* a,
+    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* b,
+    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->attachmentFeedbackLoopDynamicState) == (b->attachmentFeedbackLoopDynamicState))) {
+        onFail("a->attachmentFeedbackLoopDynamicState (Error: Value not equal)");
+    };
+}
+
+#endif
+#ifdef VK_KHR_acceleration_structure
 void checkEqual_VkAccelerationStructureBuildRangeInfoKHR(
     const VkAccelerationStructureBuildRangeInfoKHR* a,
     const VkAccelerationStructureBuildRangeInfoKHR* b, OnFailCompareFunc onFail) {
@@ -17943,6 +21730,147 @@ void checkEqual_VkPhysicalDeviceRayQueryFeaturesKHR(const VkPhysicalDeviceRayQue
 }
 
 #endif
+#ifdef VK_EXT_mesh_shader
+void checkEqual_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    const VkPhysicalDeviceMeshShaderFeaturesEXT* a, const VkPhysicalDeviceMeshShaderFeaturesEXT* b,
+    OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->taskShader) == (b->taskShader))) {
+        onFail("a->taskShader (Error: Value not equal)");
+    };
+    if (!((a->meshShader) == (b->meshShader))) {
+        onFail("a->meshShader (Error: Value not equal)");
+    };
+    if (!((a->multiviewMeshShader) == (b->multiviewMeshShader))) {
+        onFail("a->multiviewMeshShader (Error: Value not equal)");
+    };
+    if (!((a->primitiveFragmentShadingRateMeshShader) ==
+          (b->primitiveFragmentShadingRateMeshShader))) {
+        onFail("a->primitiveFragmentShadingRateMeshShader (Error: Value not equal)");
+    };
+    if (!((a->meshShaderQueries) == (b->meshShaderQueries))) {
+        onFail("a->meshShaderQueries (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    const VkPhysicalDeviceMeshShaderPropertiesEXT* a,
+    const VkPhysicalDeviceMeshShaderPropertiesEXT* b, OnFailCompareFunc onFail) {
+    if (!((a->sType) == (b->sType))) {
+        onFail("a->sType (Error: Value not equal)");
+    };
+    if (a->pNext) {
+        checkEqual_extension_struct(a->pNext, b->pNext, onFail);
+    }
+    if (!((a->maxTaskWorkGroupTotalCount) == (b->maxTaskWorkGroupTotalCount))) {
+        onFail("a->maxTaskWorkGroupTotalCount (Error: Value not equal)");
+    };
+    if (!((memcmp(a->maxTaskWorkGroupCount, b->maxTaskWorkGroupCount, 3 * sizeof(uint32_t)) ==
+           0))) {
+        onFail("a->maxTaskWorkGroupCount (Error: Unequal static array)");
+    };
+    if (!((a->maxTaskWorkGroupInvocations) == (b->maxTaskWorkGroupInvocations))) {
+        onFail("a->maxTaskWorkGroupInvocations (Error: Value not equal)");
+    };
+    if (!((memcmp(a->maxTaskWorkGroupSize, b->maxTaskWorkGroupSize, 3 * sizeof(uint32_t)) == 0))) {
+        onFail("a->maxTaskWorkGroupSize (Error: Unequal static array)");
+    };
+    if (!((a->maxTaskPayloadSize) == (b->maxTaskPayloadSize))) {
+        onFail("a->maxTaskPayloadSize (Error: Value not equal)");
+    };
+    if (!((a->maxTaskSharedMemorySize) == (b->maxTaskSharedMemorySize))) {
+        onFail("a->maxTaskSharedMemorySize (Error: Value not equal)");
+    };
+    if (!((a->maxTaskPayloadAndSharedMemorySize) == (b->maxTaskPayloadAndSharedMemorySize))) {
+        onFail("a->maxTaskPayloadAndSharedMemorySize (Error: Value not equal)");
+    };
+    if (!((a->maxMeshWorkGroupTotalCount) == (b->maxMeshWorkGroupTotalCount))) {
+        onFail("a->maxMeshWorkGroupTotalCount (Error: Value not equal)");
+    };
+    if (!((memcmp(a->maxMeshWorkGroupCount, b->maxMeshWorkGroupCount, 3 * sizeof(uint32_t)) ==
+           0))) {
+        onFail("a->maxMeshWorkGroupCount (Error: Unequal static array)");
+    };
+    if (!((a->maxMeshWorkGroupInvocations) == (b->maxMeshWorkGroupInvocations))) {
+        onFail("a->maxMeshWorkGroupInvocations (Error: Value not equal)");
+    };
+    if (!((memcmp(a->maxMeshWorkGroupSize, b->maxMeshWorkGroupSize, 3 * sizeof(uint32_t)) == 0))) {
+        onFail("a->maxMeshWorkGroupSize (Error: Unequal static array)");
+    };
+    if (!((a->maxMeshSharedMemorySize) == (b->maxMeshSharedMemorySize))) {
+        onFail("a->maxMeshSharedMemorySize (Error: Value not equal)");
+    };
+    if (!((a->maxMeshPayloadAndSharedMemorySize) == (b->maxMeshPayloadAndSharedMemorySize))) {
+        onFail("a->maxMeshPayloadAndSharedMemorySize (Error: Value not equal)");
+    };
+    if (!((a->maxMeshOutputMemorySize) == (b->maxMeshOutputMemorySize))) {
+        onFail("a->maxMeshOutputMemorySize (Error: Value not equal)");
+    };
+    if (!((a->maxMeshPayloadAndOutputMemorySize) == (b->maxMeshPayloadAndOutputMemorySize))) {
+        onFail("a->maxMeshPayloadAndOutputMemorySize (Error: Value not equal)");
+    };
+    if (!((a->maxMeshOutputComponents) == (b->maxMeshOutputComponents))) {
+        onFail("a->maxMeshOutputComponents (Error: Value not equal)");
+    };
+    if (!((a->maxMeshOutputVertices) == (b->maxMeshOutputVertices))) {
+        onFail("a->maxMeshOutputVertices (Error: Value not equal)");
+    };
+    if (!((a->maxMeshOutputPrimitives) == (b->maxMeshOutputPrimitives))) {
+        onFail("a->maxMeshOutputPrimitives (Error: Value not equal)");
+    };
+    if (!((a->maxMeshOutputLayers) == (b->maxMeshOutputLayers))) {
+        onFail("a->maxMeshOutputLayers (Error: Value not equal)");
+    };
+    if (!((a->maxMeshMultiviewViewCount) == (b->maxMeshMultiviewViewCount))) {
+        onFail("a->maxMeshMultiviewViewCount (Error: Value not equal)");
+    };
+    if (!((a->meshOutputPerVertexGranularity) == (b->meshOutputPerVertexGranularity))) {
+        onFail("a->meshOutputPerVertexGranularity (Error: Value not equal)");
+    };
+    if (!((a->meshOutputPerPrimitiveGranularity) == (b->meshOutputPerPrimitiveGranularity))) {
+        onFail("a->meshOutputPerPrimitiveGranularity (Error: Value not equal)");
+    };
+    if (!((a->maxPreferredTaskWorkGroupInvocations) == (b->maxPreferredTaskWorkGroupInvocations))) {
+        onFail("a->maxPreferredTaskWorkGroupInvocations (Error: Value not equal)");
+    };
+    if (!((a->maxPreferredMeshWorkGroupInvocations) == (b->maxPreferredMeshWorkGroupInvocations))) {
+        onFail("a->maxPreferredMeshWorkGroupInvocations (Error: Value not equal)");
+    };
+    if (!((a->prefersLocalInvocationVertexOutput) == (b->prefersLocalInvocationVertexOutput))) {
+        onFail("a->prefersLocalInvocationVertexOutput (Error: Value not equal)");
+    };
+    if (!((a->prefersLocalInvocationPrimitiveOutput) ==
+          (b->prefersLocalInvocationPrimitiveOutput))) {
+        onFail("a->prefersLocalInvocationPrimitiveOutput (Error: Value not equal)");
+    };
+    if (!((a->prefersCompactVertexOutput) == (b->prefersCompactVertexOutput))) {
+        onFail("a->prefersCompactVertexOutput (Error: Value not equal)");
+    };
+    if (!((a->prefersCompactPrimitiveOutput) == (b->prefersCompactPrimitiveOutput))) {
+        onFail("a->prefersCompactPrimitiveOutput (Error: Value not equal)");
+    };
+}
+
+void checkEqual_VkDrawMeshTasksIndirectCommandEXT(const VkDrawMeshTasksIndirectCommandEXT* a,
+                                                  const VkDrawMeshTasksIndirectCommandEXT* b,
+                                                  OnFailCompareFunc onFail) {
+    if (!((a->groupCountX) == (b->groupCountX))) {
+        onFail("a->groupCountX (Error: Value not equal)");
+    };
+    if (!((a->groupCountY) == (b->groupCountY))) {
+        onFail("a->groupCountY (Error: Value not equal)");
+    };
+    if (!((a->groupCountZ) == (b->groupCountZ))) {
+        onFail("a->groupCountZ (Error: Value not equal)");
+    };
+}
+
+#endif
 void checkEqual_extension_struct(const void* structExtension, const void* structExtension2,
                                  OnFailCompareFunc onFail) {
     if (!structExtension) {
@@ -17950,6 +21878,14 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
     }
     uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension);
     switch (structType) {
+#ifdef VK_VERSION_1_0
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
+            checkEqual_VkShaderModuleCreateInfo(
+                reinterpret_cast<const VkShaderModuleCreateInfo*>(structExtension),
+                reinterpret_cast<const VkShaderModuleCreateInfo*>(structExtension2), onFail);
+            break;
+        }
+#endif
 #ifdef VK_VERSION_1_1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
             checkEqual_VkPhysicalDeviceSubgroupProperties(
@@ -18512,6 +22448,235 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
+            checkEqual_VkPhysicalDeviceVulkan13Features(
+                reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceVulkan13Features*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: {
+            checkEqual_VkPhysicalDeviceVulkan13Properties(
+                reinterpret_cast<const VkPhysicalDeviceVulkan13Properties*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceVulkan13Properties*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: {
+            checkEqual_VkPipelineCreationFeedbackCreateInfo(
+                reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo*>(structExtension),
+                reinterpret_cast<const VkPipelineCreationFeedbackCreateInfo*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
+            checkEqual_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+                reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
+            checkEqual_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+                reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
+            checkEqual_VkPhysicalDevicePrivateDataFeatures(
+                reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(structExtension),
+                reinterpret_cast<const VkPhysicalDevicePrivateDataFeatures*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: {
+            checkEqual_VkDevicePrivateDataCreateInfo(
+                reinterpret_cast<const VkDevicePrivateDataCreateInfo*>(structExtension),
+                reinterpret_cast<const VkDevicePrivateDataCreateInfo*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
+            checkEqual_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+                reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: {
+            checkEqual_VkMemoryBarrier2(reinterpret_cast<const VkMemoryBarrier2*>(structExtension),
+                                        reinterpret_cast<const VkMemoryBarrier2*>(structExtension2),
+                                        onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
+            checkEqual_VkPhysicalDeviceSynchronization2Features(
+                reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceSynchronization2Features*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
+            checkEqual_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+                reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
+            checkEqual_VkPhysicalDeviceImageRobustnessFeatures(
+                reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeatures*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
+            checkEqual_VkPhysicalDeviceSubgroupSizeControlFeatures(
+                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeatures*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
+            checkEqual_VkPhysicalDeviceSubgroupSizeControlProperties(
+                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlProperties*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: {
+            checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+                reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(
+                    structExtension),
+                reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
+            checkEqual_VkPhysicalDeviceInlineUniformBlockFeatures(
+                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeatures*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
+            checkEqual_VkPhysicalDeviceInlineUniformBlockProperties(
+                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockProperties*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: {
+            checkEqual_VkWriteDescriptorSetInlineUniformBlock(
+                reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock*>(structExtension),
+                reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlock*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: {
+            checkEqual_VkDescriptorPoolInlineUniformBlockCreateInfo(
+                reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo*>(
+                    structExtension),
+                reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfo*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
+            checkEqual_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+                reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: {
+            checkEqual_VkPipelineRenderingCreateInfo(
+                reinterpret_cast<const VkPipelineRenderingCreateInfo*>(structExtension),
+                reinterpret_cast<const VkPipelineRenderingCreateInfo*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
+            checkEqual_VkPhysicalDeviceDynamicRenderingFeatures(
+                reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeatures*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: {
+            checkEqual_VkCommandBufferInheritanceRenderingInfo(
+                reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo*>(structExtension),
+                reinterpret_cast<const VkCommandBufferInheritanceRenderingInfo*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
+            checkEqual_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
+            checkEqual_VkPhysicalDeviceShaderIntegerDotProductProperties(
+                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductProperties*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
+            checkEqual_VkPhysicalDeviceTexelBufferAlignmentProperties(
+                reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentProperties*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
+            checkEqual_VkFormatProperties3(
+                reinterpret_cast<const VkFormatProperties3*>(structExtension),
+                reinterpret_cast<const VkFormatProperties3*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
+            checkEqual_VkPhysicalDeviceMaintenance4Features(
+                reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceMaintenance4Features*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
+            checkEqual_VkPhysicalDeviceMaintenance4Properties(
+                reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceMaintenance4Properties*>(structExtension2),
+                onFail);
+            break;
+        }
+#endif
 #ifdef VK_KHR_swapchain
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
             checkEqual_VkImageSwapchainCreateInfoKHR(
@@ -18549,52 +22714,94 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
         }
 #endif
 #ifdef VK_KHR_video_queue
-        case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
-            checkEqual_VkVideoQueueFamilyProperties2KHR(
-                reinterpret_cast<const VkVideoQueueFamilyProperties2KHR*>(structExtension),
-                reinterpret_cast<const VkVideoQueueFamilyProperties2KHR*>(structExtension2),
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: {
+            checkEqual_VkQueueFamilyQueryResultStatusPropertiesKHR(
+                reinterpret_cast<const VkQueueFamilyQueryResultStatusPropertiesKHR*>(
+                    structExtension),
+                reinterpret_cast<const VkQueueFamilyQueryResultStatusPropertiesKHR*>(
+                    structExtension2),
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
-            checkEqual_VkVideoProfileKHR(
-                reinterpret_cast<const VkVideoProfileKHR*>(structExtension),
-                reinterpret_cast<const VkVideoProfileKHR*>(structExtension2), onFail);
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: {
+            checkEqual_VkQueueFamilyVideoPropertiesKHR(
+                reinterpret_cast<const VkQueueFamilyVideoPropertiesKHR*>(structExtension),
+                reinterpret_cast<const VkQueueFamilyVideoPropertiesKHR*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: {
+            checkEqual_VkVideoProfileInfoKHR(
+                reinterpret_cast<const VkVideoProfileInfoKHR*>(structExtension),
+                reinterpret_cast<const VkVideoProfileInfoKHR*>(structExtension2), onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
-            checkEqual_VkVideoProfilesKHR(
-                reinterpret_cast<const VkVideoProfilesKHR*>(structExtension),
-                reinterpret_cast<const VkVideoProfilesKHR*>(structExtension2), onFail);
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: {
+            checkEqual_VkVideoProfileListInfoKHR(
+                reinterpret_cast<const VkVideoProfileListInfoKHR*>(structExtension),
+                reinterpret_cast<const VkVideoProfileListInfoKHR*>(structExtension2), onFail);
             break;
         }
 #endif
-#ifdef VK_KHR_dynamic_rendering
-        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
-            checkEqual_VkPipelineRenderingCreateInfoKHR(
-                reinterpret_cast<const VkPipelineRenderingCreateInfoKHR*>(structExtension),
-                reinterpret_cast<const VkPipelineRenderingCreateInfoKHR*>(structExtension2),
+#ifdef VK_KHR_video_decode_queue
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: {
+            checkEqual_VkVideoDecodeCapabilitiesKHR(
+                reinterpret_cast<const VkVideoDecodeCapabilitiesKHR*>(structExtension),
+                reinterpret_cast<const VkVideoDecodeCapabilitiesKHR*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: {
+            checkEqual_VkVideoDecodeUsageInfoKHR(
+                reinterpret_cast<const VkVideoDecodeUsageInfoKHR*>(structExtension),
+                reinterpret_cast<const VkVideoDecodeUsageInfoKHR*>(structExtension2), onFail);
+            break;
+        }
+#endif
+#ifdef VK_KHR_video_decode_h264
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: {
+            checkEqual_VkVideoDecodeH264ProfileInfoKHR(
+                reinterpret_cast<const VkVideoDecodeH264ProfileInfoKHR*>(structExtension),
+                reinterpret_cast<const VkVideoDecodeH264ProfileInfoKHR*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: {
+            checkEqual_VkVideoDecodeH264CapabilitiesKHR(
+                reinterpret_cast<const VkVideoDecodeH264CapabilitiesKHR*>(structExtension),
+                reinterpret_cast<const VkVideoDecodeH264CapabilitiesKHR*>(structExtension2),
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
-            checkEqual_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
-                reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            checkEqual_VkVideoDecodeH264SessionParametersAddInfoKHR(
+                reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoKHR*>(
                     structExtension),
-                reinterpret_cast<const VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+                reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoKHR*>(
                     structExtension2),
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
-            checkEqual_VkCommandBufferInheritanceRenderingInfoKHR(
-                reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR*>(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            checkEqual_VkVideoDecodeH264SessionParametersCreateInfoKHR(
+                reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoKHR*>(
                     structExtension),
-                reinterpret_cast<const VkCommandBufferInheritanceRenderingInfoKHR*>(
+                reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoKHR*>(
                     structExtension2),
                 onFail);
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: {
+            checkEqual_VkVideoDecodeH264PictureInfoKHR(
+                reinterpret_cast<const VkVideoDecodeH264PictureInfoKHR*>(structExtension),
+                reinterpret_cast<const VkVideoDecodeH264PictureInfoKHR*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: {
+            checkEqual_VkVideoDecodeH264DpbSlotInfoKHR(
+                reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR*>(structExtension),
+                reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoKHR*>(structExtension2), onFail);
+            break;
+        }
+#endif
+#ifdef VK_KHR_dynamic_rendering
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
             checkEqual_VkRenderingFragmentShadingRateAttachmentInfoKHR(
                 reinterpret_cast<const VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
@@ -18745,6 +22952,7 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
         }
 #endif
 #ifdef VK_KHR_portability_subset
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
             checkEqual_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
                 reinterpret_cast<const VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
@@ -18754,6 +22962,8 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
                 onFail);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
             checkEqual_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
                 reinterpret_cast<const VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
@@ -18763,6 +22973,7 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
                 onFail);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_shader_clock
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
@@ -18773,16 +22984,75 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_KHR_shader_terminate_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
-            checkEqual_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
-                reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+#ifdef VK_KHR_video_decode_h265
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: {
+            checkEqual_VkVideoDecodeH265ProfileInfoKHR(
+                reinterpret_cast<const VkVideoDecodeH265ProfileInfoKHR*>(structExtension),
+                reinterpret_cast<const VkVideoDecodeH265ProfileInfoKHR*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: {
+            checkEqual_VkVideoDecodeH265CapabilitiesKHR(
+                reinterpret_cast<const VkVideoDecodeH265CapabilitiesKHR*>(structExtension),
+                reinterpret_cast<const VkVideoDecodeH265CapabilitiesKHR*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            checkEqual_VkVideoDecodeH265SessionParametersAddInfoKHR(
+                reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoKHR*>(
+                    structExtension),
+                reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoKHR*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            checkEqual_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+                reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoKHR*>(
                     structExtension),
-                reinterpret_cast<const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
+                reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoKHR*>(
                     structExtension2),
                 onFail);
             break;
         }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: {
+            checkEqual_VkVideoDecodeH265PictureInfoKHR(
+                reinterpret_cast<const VkVideoDecodeH265PictureInfoKHR*>(structExtension),
+                reinterpret_cast<const VkVideoDecodeH265PictureInfoKHR*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: {
+            checkEqual_VkVideoDecodeH265DpbSlotInfoKHR(
+                reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR*>(structExtension),
+                reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoKHR*>(structExtension2), onFail);
+            break;
+        }
+#endif
+#ifdef VK_KHR_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: {
+            checkEqual_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+                reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoKHR*>(structExtension),
+                reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoKHR*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: {
+            checkEqual_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+                reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: {
+            checkEqual_VkQueueFamilyGlobalPriorityPropertiesKHR(
+                reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesKHR*>(structExtension),
+                reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesKHR*>(structExtension2),
+                onFail);
+            break;
+        }
 #endif
 #ifdef VK_KHR_fragment_shading_rate
         case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
@@ -18849,23 +23119,11 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
-            checkEqual_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
-                    structExtension),
-                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
-            checkEqual_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
-                    structExtension),
-                reinterpret_cast<const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
-                    structExtension2),
-                onFail);
+#ifdef VK_KHR_pipeline_library
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+            checkEqual_VkPipelineLibraryCreateInfoKHR(
+                reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>(structExtension),
+                reinterpret_cast<const VkPipelineLibraryCreateInfoKHR*>(structExtension2), onFail);
             break;
         }
 #endif
@@ -18885,33 +23143,76 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
         }
 #endif
 #ifdef VK_KHR_video_encode_queue
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: {
+            checkEqual_VkVideoEncodeCapabilitiesKHR(
+                reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>(structExtension),
+                reinterpret_cast<const VkVideoEncodeCapabilitiesKHR*>(structExtension2), onFail);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: {
+            checkEqual_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+                reinterpret_cast<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(
+                    structExtension),
+                reinterpret_cast<const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: {
+            checkEqual_VkVideoEncodeUsageInfoKHR(
+                reinterpret_cast<const VkVideoEncodeUsageInfoKHR*>(structExtension),
+                reinterpret_cast<const VkVideoEncodeUsageInfoKHR*>(structExtension2), onFail);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: {
+            checkEqual_VkVideoEncodeRateControlLayerInfoKHR(
+                reinterpret_cast<const VkVideoEncodeRateControlLayerInfoKHR*>(structExtension),
+                reinterpret_cast<const VkVideoEncodeRateControlLayerInfoKHR*>(structExtension2),
+                onFail);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
             checkEqual_VkVideoEncodeRateControlInfoKHR(
                 reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(structExtension),
                 reinterpret_cast<const VkVideoEncodeRateControlInfoKHR*>(structExtension2), onFail);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_synchronization2
-        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
-            checkEqual_VkMemoryBarrier2KHR(
-                reinterpret_cast<const VkMemoryBarrier2KHR*>(structExtension),
-                reinterpret_cast<const VkMemoryBarrier2KHR*>(structExtension2), onFail);
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
+            checkEqual_VkQueueFamilyCheckpointProperties2NV(
+                reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension),
+                reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension2),
+                onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
-            checkEqual_VkPhysicalDeviceSynchronization2FeaturesKHR(
-                reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+#endif
+#ifdef VK_KHR_fragment_shader_barycentric
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
+            checkEqual_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(
                     structExtension),
-                reinterpret_cast<const VkPhysicalDeviceSynchronization2FeaturesKHR*>(
+                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(
                     structExtension2),
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
-            checkEqual_VkQueueFamilyCheckpointProperties2NV(
-                reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension),
-                reinterpret_cast<const VkQueueFamilyCheckpointProperties2NV*>(structExtension2),
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: {
+            checkEqual_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(
+                    structExtension2),
                 onFail);
             break;
         }
@@ -18929,17 +23230,6 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_KHR_zero_initialize_workgroup_memory
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
-            checkEqual_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-                reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
-                    structExtension),
-                reinterpret_cast<const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-#endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: {
             checkEqual_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
@@ -18951,26 +23241,23 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_KHR_format_feature_flags2
-        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
-            checkEqual_VkFormatProperties3KHR(
-                reinterpret_cast<const VkFormatProperties3KHR*>(structExtension),
-                reinterpret_cast<const VkFormatProperties3KHR*>(structExtension2), onFail);
-            break;
-        }
-#endif
-#ifdef VK_KHR_maintenance4
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
-            checkEqual_VkPhysicalDeviceMaintenance4FeaturesKHR(
-                reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension),
-                reinterpret_cast<const VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension2),
+#ifdef VK_KHR_ray_tracing_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
+            checkEqual_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+                reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
+                    structExtension2),
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
-            checkEqual_VkPhysicalDeviceMaintenance4PropertiesKHR(
-                reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension),
-                reinterpret_cast<const VkPhysicalDeviceMaintenance4PropertiesKHR*>(
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
+            checkEqual_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+                reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(
                     structExtension2),
                 onFail);
             break;
@@ -19058,6 +23345,7 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
         }
 #endif
 #ifdef VK_EXT_video_encode_h264
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
             checkEqual_VkVideoEncodeH264CapabilitiesEXT(
                 reinterpret_cast<const VkVideoEncodeH264CapabilitiesEXT*>(structExtension),
@@ -19065,13 +23353,8 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
-            checkEqual_VkVideoEncodeH264SessionCreateInfoEXT(
-                reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension),
-                reinterpret_cast<const VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension2),
-                onFail);
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
             checkEqual_VkVideoEncodeH264SessionParametersAddInfoEXT(
                 reinterpret_cast<const VkVideoEncodeH264SessionParametersAddInfoEXT*>(
@@ -19081,6 +23364,8 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
                 onFail);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             checkEqual_VkVideoEncodeH264SessionParametersCreateInfoEXT(
                 reinterpret_cast<const VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
@@ -19090,6 +23375,8 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
                 onFail);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
             checkEqual_VkVideoEncodeH264VclFrameInfoEXT(
                 reinterpret_cast<const VkVideoEncodeH264VclFrameInfoEXT*>(structExtension),
@@ -19097,22 +23384,44 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
-            checkEqual_VkVideoEncodeH264EmitPictureParametersEXT(
-                reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension),
-                reinterpret_cast<const VkVideoEncodeH264EmitPictureParametersEXT*>(
-                    structExtension2),
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: {
+            checkEqual_VkVideoEncodeH264DpbSlotInfoEXT(
+                reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoEXT*>(structExtension),
+                reinterpret_cast<const VkVideoEncodeH264DpbSlotInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: {
+            checkEqual_VkVideoEncodeH264ProfileInfoEXT(
+                reinterpret_cast<const VkVideoEncodeH264ProfileInfoEXT*>(structExtension),
+                reinterpret_cast<const VkVideoEncodeH264ProfileInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: {
+            checkEqual_VkVideoEncodeH264RateControlInfoEXT(
+                reinterpret_cast<const VkVideoEncodeH264RateControlInfoEXT*>(structExtension),
+                reinterpret_cast<const VkVideoEncodeH264RateControlInfoEXT*>(structExtension2),
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
-            checkEqual_VkVideoEncodeH264ProfileEXT(
-                reinterpret_cast<const VkVideoEncodeH264ProfileEXT*>(structExtension),
-                reinterpret_cast<const VkVideoEncodeH264ProfileEXT*>(structExtension2), onFail);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: {
+            checkEqual_VkVideoEncodeH264RateControlLayerInfoEXT(
+                reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoEXT*>(structExtension),
+                reinterpret_cast<const VkVideoEncodeH264RateControlLayerInfoEXT*>(structExtension2),
+                onFail);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_EXT_video_encode_h265
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
             checkEqual_VkVideoEncodeH265CapabilitiesEXT(
                 reinterpret_cast<const VkVideoEncodeH265CapabilitiesEXT*>(structExtension),
@@ -19120,13 +23429,8 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
-            checkEqual_VkVideoEncodeH265SessionCreateInfoEXT(
-                reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension),
-                reinterpret_cast<const VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension2),
-                onFail);
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
             checkEqual_VkVideoEncodeH265SessionParametersAddInfoEXT(
                 reinterpret_cast<const VkVideoEncodeH265SessionParametersAddInfoEXT*>(
@@ -19136,6 +23440,8 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
                 onFail);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             checkEqual_VkVideoEncodeH265SessionParametersCreateInfoEXT(
                 reinterpret_cast<const VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
@@ -19145,6 +23451,8 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
                 onFail);
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
             checkEqual_VkVideoEncodeH265VclFrameInfoEXT(
                 reinterpret_cast<const VkVideoEncodeH265VclFrameInfoEXT*>(structExtension),
@@ -19152,78 +23460,41 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
-            checkEqual_VkVideoEncodeH265EmitPictureParametersEXT(
-                reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension),
-                reinterpret_cast<const VkVideoEncodeH265EmitPictureParametersEXT*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
-            checkEqual_VkVideoEncodeH265ProfileEXT(
-                reinterpret_cast<const VkVideoEncodeH265ProfileEXT*>(structExtension),
-                reinterpret_cast<const VkVideoEncodeH265ProfileEXT*>(structExtension2), onFail);
-            break;
-        }
-#endif
-#ifdef VK_EXT_video_decode_h264
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
-            checkEqual_VkVideoDecodeH264ProfileEXT(
-                reinterpret_cast<const VkVideoDecodeH264ProfileEXT*>(structExtension),
-                reinterpret_cast<const VkVideoDecodeH264ProfileEXT*>(structExtension2), onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
-            checkEqual_VkVideoDecodeH264CapabilitiesEXT(
-                reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT*>(structExtension),
-                reinterpret_cast<const VkVideoDecodeH264CapabilitiesEXT*>(structExtension2),
-                onFail);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: {
+            checkEqual_VkVideoEncodeH265DpbSlotInfoEXT(
+                reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoEXT*>(structExtension),
+                reinterpret_cast<const VkVideoEncodeH265DpbSlotInfoEXT*>(structExtension2), onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
-            checkEqual_VkVideoDecodeH264SessionCreateInfoEXT(
-                reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension),
-                reinterpret_cast<const VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension2),
-                onFail);
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: {
+            checkEqual_VkVideoEncodeH265ProfileInfoEXT(
+                reinterpret_cast<const VkVideoEncodeH265ProfileInfoEXT*>(structExtension),
+                reinterpret_cast<const VkVideoEncodeH265ProfileInfoEXT*>(structExtension2), onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            checkEqual_VkVideoDecodeH264SessionParametersAddInfoEXT(
-                reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT*>(
-                    structExtension),
-                reinterpret_cast<const VkVideoDecodeH264SessionParametersAddInfoEXT*>(
-                    structExtension2),
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: {
+            checkEqual_VkVideoEncodeH265RateControlInfoEXT(
+                reinterpret_cast<const VkVideoEncodeH265RateControlInfoEXT*>(structExtension),
+                reinterpret_cast<const VkVideoEncodeH265RateControlInfoEXT*>(structExtension2),
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            checkEqual_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-                reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
-                    structExtension),
-                reinterpret_cast<const VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
-                    structExtension2),
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: {
+            checkEqual_VkVideoEncodeH265RateControlLayerInfoEXT(
+                reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoEXT*>(structExtension),
+                reinterpret_cast<const VkVideoEncodeH265RateControlLayerInfoEXT*>(structExtension2),
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
-            checkEqual_VkVideoDecodeH264PictureInfoEXT(
-                reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT*>(structExtension),
-                reinterpret_cast<const VkVideoDecodeH264PictureInfoEXT*>(structExtension2), onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
-            checkEqual_VkVideoDecodeH264MvcEXT(
-                reinterpret_cast<const VkVideoDecodeH264MvcEXT*>(structExtension),
-                reinterpret_cast<const VkVideoDecodeH264MvcEXT*>(structExtension2), onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
-            checkEqual_VkVideoDecodeH264DpbSlotInfoEXT(
-                reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension),
-                reinterpret_cast<const VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension2), onFail);
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
@@ -19291,17 +23562,6 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_EXT_texture_compression_astc_hdr
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
-            checkEqual_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-                reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
-                    structExtension),
-                reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-#endif
 #ifdef VK_EXT_astc_decode_mode
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
             checkEqual_VkImageViewASTCDecodeModeEXT(
@@ -19317,6 +23577,33 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_robustness
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: {
+            checkEqual_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: {
+            checkEqual_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+                reinterpret_cast<const VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: {
+            checkEqual_VkPipelineRobustnessCreateInfoEXT(
+                reinterpret_cast<const VkPipelineRobustnessCreateInfoEXT*>(structExtension),
+                reinterpret_cast<const VkPipelineRobustnessCreateInfoEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+#endif
 #ifdef VK_EXT_conditional_rendering
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
             checkEqual_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
@@ -19447,6 +23734,12 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
         }
 #endif
 #ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+            checkEqual_VkDebugUtilsObjectNameInfoEXT(
+                reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(structExtension),
+                reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(structExtension2), onFail);
+            break;
+        }
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
             checkEqual_VkDebugUtilsMessengerCreateInfoEXT(
                 reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension),
@@ -19495,43 +23788,6 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_EXT_inline_uniform_block
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
-            checkEqual_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
-                    structExtension),
-                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
-            checkEqual_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
-                    structExtension),
-                reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
-            checkEqual_VkWriteDescriptorSetInlineUniformBlockEXT(
-                reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension),
-                reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
-            checkEqual_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-                reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
-                    structExtension),
-                reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-#endif
 #ifdef VK_EXT_sample_locations
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
             checkEqual_VkSampleLocationsInfoEXT(
@@ -19785,15 +24041,6 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
-            checkEqual_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-                reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension),
-                reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension2),
-                onFail);
-            break;
-        }
-#endif
 #ifdef VK_EXT_external_memory_host
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
             checkEqual_VkImportMemoryHostPointerInfoEXT(
@@ -19830,58 +24077,6 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_EXT_video_decode_h265
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
-            checkEqual_VkVideoDecodeH265ProfileEXT(
-                reinterpret_cast<const VkVideoDecodeH265ProfileEXT*>(structExtension),
-                reinterpret_cast<const VkVideoDecodeH265ProfileEXT*>(structExtension2), onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
-            checkEqual_VkVideoDecodeH265CapabilitiesEXT(
-                reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT*>(structExtension),
-                reinterpret_cast<const VkVideoDecodeH265CapabilitiesEXT*>(structExtension2),
-                onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
-            checkEqual_VkVideoDecodeH265SessionCreateInfoEXT(
-                reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension),
-                reinterpret_cast<const VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension2),
-                onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            checkEqual_VkVideoDecodeH265SessionParametersAddInfoEXT(
-                reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT*>(
-                    structExtension),
-                reinterpret_cast<const VkVideoDecodeH265SessionParametersAddInfoEXT*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            checkEqual_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-                reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
-                    structExtension),
-                reinterpret_cast<const VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
-            checkEqual_VkVideoDecodeH265PictureInfoEXT(
-                reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT*>(structExtension),
-                reinterpret_cast<const VkVideoDecodeH265PictureInfoEXT*>(structExtension2), onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
-            checkEqual_VkVideoDecodeH265DpbSlotInfoEXT(
-                reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension),
-                reinterpret_cast<const VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension2), onFail);
-            break;
-        }
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
             checkEqual_VkDeviceMemoryOverallocationCreateInfoAMD(
@@ -19929,15 +24124,6 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_EXT_pipeline_creation_feedback
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
-            checkEqual_VkPipelineCreationFeedbackCreateInfoEXT(
-                reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension),
-                reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension2),
-                onFail);
-            break;
-        }
-#endif
 #ifdef VK_NV_compute_shader_derivatives
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
             checkEqual_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
@@ -19965,17 +24151,6 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_NV_fragment_shader_barycentric
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
-            checkEqual_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
-                    structExtension),
-                reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-#endif
 #ifdef VK_NV_shader_image_footprint
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
             checkEqual_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -20092,35 +24267,6 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_EXT_subgroup_size_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
-            checkEqual_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
-                    structExtension),
-                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
-            checkEqual_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
-                    structExtension),
-                reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
-            checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-                reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
-                    structExtension),
-                reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
-#endif
 #ifdef VK_AMD_shader_core_properties2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
             checkEqual_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -20402,16 +24548,64 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
-            checkEqual_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
-                reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+#ifdef VK_EXT_surface_maintenance1
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: {
+            checkEqual_VkSurfacePresentModeEXT(
+                reinterpret_cast<const VkSurfacePresentModeEXT*>(structExtension),
+                reinterpret_cast<const VkSurfacePresentModeEXT*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
+            checkEqual_VkSurfacePresentScalingCapabilitiesEXT(
+                reinterpret_cast<const VkSurfacePresentScalingCapabilitiesEXT*>(structExtension),
+                reinterpret_cast<const VkSurfacePresentScalingCapabilitiesEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
+            checkEqual_VkSurfacePresentModeCompatibilityEXT(
+                reinterpret_cast<const VkSurfacePresentModeCompatibilityEXT*>(structExtension),
+                reinterpret_cast<const VkSurfacePresentModeCompatibilityEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(
                     structExtension),
-                reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+                reinterpret_cast<const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(
                     structExtension2),
                 onFail);
             break;
         }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: {
+            checkEqual_VkSwapchainPresentFenceInfoEXT(
+                reinterpret_cast<const VkSwapchainPresentFenceInfoEXT*>(structExtension),
+                reinterpret_cast<const VkSwapchainPresentFenceInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: {
+            checkEqual_VkSwapchainPresentModesCreateInfoEXT(
+                reinterpret_cast<const VkSwapchainPresentModesCreateInfoEXT*>(structExtension),
+                reinterpret_cast<const VkSwapchainPresentModesCreateInfoEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: {
+            checkEqual_VkSwapchainPresentModeInfoEXT(
+                reinterpret_cast<const VkSwapchainPresentModeInfoEXT*>(structExtension),
+                reinterpret_cast<const VkSwapchainPresentModeInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: {
+            checkEqual_VkSwapchainPresentScalingCreateInfoEXT(
+                reinterpret_cast<const VkSwapchainPresentScalingCreateInfoEXT*>(structExtension),
+                reinterpret_cast<const VkSwapchainPresentScalingCreateInfoEXT*>(structExtension2),
+                onFail);
+            break;
+        }
 #endif
 #ifdef VK_NV_device_generated_commands
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
@@ -20472,15 +24666,6 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
-            checkEqual_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-                reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
-                    structExtension),
-                reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
-                    structExtension2),
-                onFail);
-            break;
-        }
 #endif
 #ifdef VK_QCOM_render_pass_transform
         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
@@ -20561,29 +24746,25 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_EXT_private_data
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
-            checkEqual_VkPhysicalDevicePrivateDataFeaturesEXT(
-                reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension),
-                reinterpret_cast<const VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension2),
+#ifdef VK_NV_present_barrier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
+            checkEqual_VkPhysicalDevicePresentBarrierFeaturesNV(
+                reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(structExtension),
+                reinterpret_cast<const VkPhysicalDevicePresentBarrierFeaturesNV*>(structExtension2),
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
-            checkEqual_VkDevicePrivateDataCreateInfoEXT(
-                reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension),
-                reinterpret_cast<const VkDevicePrivateDataCreateInfoEXT*>(structExtension2),
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: {
+            checkEqual_VkSurfaceCapabilitiesPresentBarrierNV(
+                reinterpret_cast<const VkSurfaceCapabilitiesPresentBarrierNV*>(structExtension),
+                reinterpret_cast<const VkSurfaceCapabilitiesPresentBarrierNV*>(structExtension2),
                 onFail);
             break;
         }
-#endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
-            checkEqual_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
-                reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
-                    structExtension),
-                reinterpret_cast<const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
-                    structExtension2),
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: {
+            checkEqual_VkSwapchainPresentBarrierCreateInfoNV(
+                reinterpret_cast<const VkSwapchainPresentBarrierCreateInfoNV*>(structExtension),
+                reinterpret_cast<const VkSwapchainPresentBarrierCreateInfoNV*>(structExtension2),
                 onFail);
             break;
         }
@@ -20606,6 +24787,169 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
+#ifdef VK_NV_low_latency
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: {
+            checkEqual_VkQueryLowLatencySupportNV(
+                reinterpret_cast<const VkQueryLowLatencySupportNV*>(structExtension),
+                reinterpret_cast<const VkQueryLowLatencySupportNV*>(structExtension2), onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_metal_objects
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: {
+            checkEqual_VkExportMetalObjectCreateInfoEXT(
+                reinterpret_cast<const VkExportMetalObjectCreateInfoEXT*>(structExtension),
+                reinterpret_cast<const VkExportMetalObjectCreateInfoEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: {
+            checkEqual_VkExportMetalDeviceInfoEXT(
+                reinterpret_cast<const VkExportMetalDeviceInfoEXT*>(structExtension),
+                reinterpret_cast<const VkExportMetalDeviceInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: {
+            checkEqual_VkExportMetalCommandQueueInfoEXT(
+                reinterpret_cast<const VkExportMetalCommandQueueInfoEXT*>(structExtension),
+                reinterpret_cast<const VkExportMetalCommandQueueInfoEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: {
+            checkEqual_VkExportMetalBufferInfoEXT(
+                reinterpret_cast<const VkExportMetalBufferInfoEXT*>(structExtension),
+                reinterpret_cast<const VkExportMetalBufferInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: {
+            checkEqual_VkImportMetalBufferInfoEXT(
+                reinterpret_cast<const VkImportMetalBufferInfoEXT*>(structExtension),
+                reinterpret_cast<const VkImportMetalBufferInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: {
+            checkEqual_VkExportMetalTextureInfoEXT(
+                reinterpret_cast<const VkExportMetalTextureInfoEXT*>(structExtension),
+                reinterpret_cast<const VkExportMetalTextureInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: {
+            checkEqual_VkImportMetalTextureInfoEXT(
+                reinterpret_cast<const VkImportMetalTextureInfoEXT*>(structExtension),
+                reinterpret_cast<const VkImportMetalTextureInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: {
+            checkEqual_VkExportMetalIOSurfaceInfoEXT(
+                reinterpret_cast<const VkExportMetalIOSurfaceInfoEXT*>(structExtension),
+                reinterpret_cast<const VkExportMetalIOSurfaceInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: {
+            checkEqual_VkImportMetalIOSurfaceInfoEXT(
+                reinterpret_cast<const VkImportMetalIOSurfaceInfoEXT*>(structExtension),
+                reinterpret_cast<const VkImportMetalIOSurfaceInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            checkEqual_VkExportMetalSharedEventInfoEXT(
+                reinterpret_cast<const VkExportMetalSharedEventInfoEXT*>(structExtension),
+                reinterpret_cast<const VkExportMetalSharedEventInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            checkEqual_VkImportMetalSharedEventInfoEXT(
+                reinterpret_cast<const VkImportMetalSharedEventInfoEXT*>(structExtension),
+                reinterpret_cast<const VkImportMetalSharedEventInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: {
+            checkEqual_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: {
+            checkEqual_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: {
+            checkEqual_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+                reinterpret_cast<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: {
+            checkEqual_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+                reinterpret_cast<const VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: {
+            checkEqual_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+                reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: {
+            checkEqual_VkGraphicsPipelineLibraryCreateInfoEXT(
+                reinterpret_cast<const VkGraphicsPipelineLibraryCreateInfoEXT*>(structExtension),
+                reinterpret_cast<const VkGraphicsPipelineLibraryCreateInfoEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
+            checkEqual_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+                reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
             checkEqual_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -20701,12 +25045,35 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_EXT_image_robustness
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
-            checkEqual_VkPhysicalDeviceImageRobustnessFeaturesEXT(
-                reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(
+#ifdef VK_EXT_image_compression_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
                     structExtension),
-                reinterpret_cast<const VkPhysicalDeviceImageRobustnessFeaturesEXT*>(
+                reinterpret_cast<const VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
+            checkEqual_VkImageCompressionControlEXT(
+                reinterpret_cast<const VkImageCompressionControlEXT*>(structExtension),
+                reinterpret_cast<const VkImageCompressionControlEXT*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
+            checkEqual_VkImageCompressionPropertiesEXT(
+                reinterpret_cast<const VkImageCompressionPropertiesEXT*>(structExtension),
+                reinterpret_cast<const VkImageCompressionPropertiesEXT*>(structExtension2), onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(
                     structExtension2),
                 onFail);
             break;
@@ -20721,6 +25088,28 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
+#ifdef VK_EXT_device_fault
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceFaultFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceFaultFeaturesEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+                reinterpret_cast<
+                    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<
+                    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
 #ifdef VK_EXT_rgba10x6_formats
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
             checkEqual_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
@@ -20733,19 +25122,19 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
         }
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
-            checkEqual_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
-                reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(
                     structExtension),
-                reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+                reinterpret_cast<const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(
                     structExtension2),
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
-            checkEqual_VkMutableDescriptorTypeCreateInfoVALVE(
-                reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension),
-                reinterpret_cast<const VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension2),
+        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: {
+            checkEqual_VkMutableDescriptorTypeCreateInfoEXT(
+                reinterpret_cast<const VkMutableDescriptorTypeCreateInfoEXT*>(structExtension),
+                reinterpret_cast<const VkMutableDescriptorTypeCreateInfoEXT*>(structExtension2),
                 onFail);
             break;
         }
@@ -20770,6 +25159,44 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
+#ifdef VK_EXT_device_address_binding_report
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: {
+            checkEqual_VkDeviceAddressBindingCallbackDataEXT(
+                reinterpret_cast<const VkDeviceAddressBindingCallbackDataEXT*>(structExtension),
+                reinterpret_cast<const VkDeviceAddressBindingCallbackDataEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clip_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceDepthClipControlFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: {
+            checkEqual_VkPipelineViewportDepthClipControlCreateInfoEXT(
+                reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPipelineViewportDepthClipControlCreateInfoEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
             checkEqual_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
@@ -20863,6 +25290,46 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
+            checkEqual_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+                reinterpret_cast<
+                    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<
+                    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: {
+            checkEqual_VkSubpassResolvePerformanceQueryEXT(
+                reinterpret_cast<const VkSubpassResolvePerformanceQueryEXT*>(structExtension),
+                reinterpret_cast<const VkSubpassResolvePerformanceQueryEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: {
+            checkEqual_VkMultisampledRenderToSingleSampledInfoEXT(
+                reinterpret_cast<const VkMultisampledRenderToSingleSampledInfoEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkMultisampledRenderToSingleSampledInfoEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
             checkEqual_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
@@ -20892,6 +25359,17 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
+#ifdef VK_EXT_primitives_generated_query
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
+            checkEqual_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
 #ifdef VK_GOOGLE_gfxstream
         case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
             checkEqual_VkImportColorBufferGOOGLE(
@@ -20912,21 +25390,20 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority_query
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
-            checkEqual_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
-                reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
+#ifdef VK_EXT_image_view_min_lod
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(
                     structExtension),
-                reinterpret_cast<const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
+                reinterpret_cast<const VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(
                     structExtension2),
                 onFail);
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
-            checkEqual_VkQueueFamilyGlobalPriorityPropertiesEXT(
-                reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension),
-                reinterpret_cast<const VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension2),
-                onFail);
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: {
+            checkEqual_VkImageViewMinLodCreateInfoEXT(
+                reinterpret_cast<const VkImageViewMinLodCreateInfoEXT*>(structExtension),
+                reinterpret_cast<const VkImageViewMinLodCreateInfoEXT*>(structExtension2), onFail);
             break;
         }
 #endif
@@ -20946,6 +25423,121 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_tile_image
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderTileImageFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: {
+            checkEqual_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+                reinterpret_cast<const VkPhysicalDeviceShaderTileImagePropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderTileImagePropertiesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: {
+            checkEqual_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+                reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: {
+            checkEqual_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+                reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkAccelerationStructureTrianglesOpacityMicromapEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_NV_displacement_micromap
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
+            checkEqual_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+                reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: {
+            checkEqual_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+                reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: {
+            checkEqual_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+                reinterpret_cast<const VkAccelerationStructureTrianglesDisplacementMicromapNV*>(
+                    structExtension),
+                reinterpret_cast<const VkAccelerationStructureTrianglesDisplacementMicromapNV*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
+            checkEqual_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+                reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: {
+            checkEqual_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+                reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
 #ifdef VK_EXT_border_color_swizzle
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
             checkEqual_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
@@ -20977,6 +25569,466 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
+#ifdef VK_ARM_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: {
+            checkEqual_VkPhysicalDeviceShaderCorePropertiesARM(
+                reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesARM*>(structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: {
+            checkEqual_VkImageViewSlicedCreateInfoEXT(
+                reinterpret_cast<const VkImageViewSlicedCreateInfoEXT*>(structExtension),
+                reinterpret_cast<const VkImageViewSlicedCreateInfoEXT*>(structExtension2), onFail);
+            break;
+        }
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
+            checkEqual_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+                reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: {
+            checkEqual_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+                reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: {
+            checkEqual_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+                reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: {
+            checkEqual_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+                reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(
+                    structExtension),
+                reinterpret_cast<const VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_NV_copy_memory_indirect
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
+            checkEqual_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+                reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: {
+            checkEqual_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+                reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_NV_memory_decompression
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: {
+            checkEqual_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+                reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: {
+            checkEqual_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+                reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_NV_linear_color_attachment
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
+            checkEqual_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+                reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+                reinterpret_cast<
+                    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<
+                    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_QCOM_image_processing
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: {
+            checkEqual_VkImageViewSampleWeightCreateInfoQCOM(
+                reinterpret_cast<const VkImageViewSampleWeightCreateInfoQCOM*>(structExtension),
+                reinterpret_cast<const VkImageViewSampleWeightCreateInfoQCOM*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
+            checkEqual_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+                reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: {
+            checkEqual_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+                reinterpret_cast<const VkPhysicalDeviceImageProcessingPropertiesQCOM*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceImageProcessingPropertiesQCOM*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: {
+            checkEqual_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+                reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: {
+            checkEqual_VkRenderPassCreationControlEXT(
+                reinterpret_cast<const VkRenderPassCreationControlEXT*>(structExtension),
+                reinterpret_cast<const VkRenderPassCreationControlEXT*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+            checkEqual_VkRenderPassCreationFeedbackCreateInfoEXT(
+                reinterpret_cast<const VkRenderPassCreationFeedbackCreateInfoEXT*>(structExtension),
+                reinterpret_cast<const VkRenderPassCreationFeedbackCreateInfoEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: {
+            checkEqual_VkRenderPassSubpassFeedbackCreateInfoEXT(
+                reinterpret_cast<const VkRenderPassSubpassFeedbackCreateInfoEXT*>(structExtension),
+                reinterpret_cast<const VkRenderPassSubpassFeedbackCreateInfoEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: {
+            checkEqual_VkDirectDriverLoadingListLUNARG(
+                reinterpret_cast<const VkDirectDriverLoadingListLUNARG*>(structExtension),
+                reinterpret_cast<const VkDirectDriverLoadingListLUNARG*>(structExtension2), onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_module_identifier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: {
+            checkEqual_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+                reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: {
+            checkEqual_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+                reinterpret_cast<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_NV_optical_flow
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
+            checkEqual_VkPhysicalDeviceOpticalFlowFeaturesNV(
+                reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceOpticalFlowFeaturesNV*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: {
+            checkEqual_VkPhysicalDeviceOpticalFlowPropertiesNV(
+                reinterpret_cast<const VkPhysicalDeviceOpticalFlowPropertiesNV*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceOpticalFlowPropertiesNV*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: {
+            checkEqual_VkOpticalFlowImageFormatInfoNV(
+                reinterpret_cast<const VkOpticalFlowImageFormatInfoNV*>(structExtension),
+                reinterpret_cast<const VkOpticalFlowImageFormatInfoNV*>(structExtension2), onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: {
+            checkEqual_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+                reinterpret_cast<const VkOpticalFlowSessionCreatePrivateDataInfoNV*>(
+                    structExtension),
+                reinterpret_cast<const VkOpticalFlowSessionCreatePrivateDataInfoNV*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_legacy_dithering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: {
+            checkEqual_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_object
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceShaderObjectFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderObjectFeaturesEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: {
+            checkEqual_VkPhysicalDeviceShaderObjectPropertiesEXT(
+                reinterpret_cast<const VkPhysicalDeviceShaderObjectPropertiesEXT*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderObjectPropertiesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_QCOM_tile_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
+            checkEqual_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+                reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_SEC_amigo_profiling
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
+            checkEqual_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+                reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: {
+            checkEqual_VkAmigoProfilingSubmitInfoSEC(
+                reinterpret_cast<const VkAmigoProfilingSubmitInfoSEC*>(structExtension),
+                reinterpret_cast<const VkAmigoProfilingSubmitInfoSEC*>(structExtension2), onFail);
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
+            checkEqual_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+                reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: {
+            checkEqual_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+                reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
+            checkEqual_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+                reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_ARM_shader_core_builtins
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
+            checkEqual_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+                reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: {
+            checkEqual_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+                reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
+            checkEqual_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
+            checkEqual_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+                reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(
+                    structExtension),
+                reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: {
+            checkEqual_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+                reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(
+                    structExtension),
+                reinterpret_cast<const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+                reinterpret_cast<
+                    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(
+                    structExtension),
+                reinterpret_cast<
+                    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(
+                    structExtension2),
+                onFail);
+            break;
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
             checkEqual_VkWriteDescriptorSetAccelerationStructureKHR(
@@ -21035,6 +26087,22 @@ void checkEqual_extension_struct(const void* structExtension, const void* struct
             break;
         }
 #endif
+#ifdef VK_EXT_mesh_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
+            checkEqual_VkPhysicalDeviceMeshShaderFeaturesEXT(
+                reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: {
+            checkEqual_VkPhysicalDeviceMeshShaderPropertiesEXT(
+                reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesEXT*>(structExtension),
+                reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesEXT*>(structExtension2),
+                onFail);
+            break;
+        }
+#endif
         default: {
             return;
         }
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_testing.h b/stream-servers/vulkan/cereal/common/goldfish_vk_testing.h
index 80c35a76..7b8256e2 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_testing.h
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_testing.h
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_testing
 //
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (header) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -874,6 +874,203 @@ void checkEqual_VkDeviceMemoryOpaqueCaptureAddressInfo(
     const VkDeviceMemoryOpaqueCaptureAddressInfo* b, OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_VERSION_1_3
+void checkEqual_VkPhysicalDeviceVulkan13Features(const VkPhysicalDeviceVulkan13Features* a,
+                                                 const VkPhysicalDeviceVulkan13Features* b,
+                                                 OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceVulkan13Properties(const VkPhysicalDeviceVulkan13Properties* a,
+                                                   const VkPhysicalDeviceVulkan13Properties* b,
+                                                   OnFailCompareFunc onFail);
+
+void checkEqual_VkPipelineCreationFeedback(const VkPipelineCreationFeedback* a,
+                                           const VkPipelineCreationFeedback* b,
+                                           OnFailCompareFunc onFail);
+
+void checkEqual_VkPipelineCreationFeedbackCreateInfo(const VkPipelineCreationFeedbackCreateInfo* a,
+                                                     const VkPipelineCreationFeedbackCreateInfo* b,
+                                                     OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    const VkPhysicalDeviceShaderTerminateInvocationFeatures* a,
+    const VkPhysicalDeviceShaderTerminateInvocationFeatures* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceToolProperties(const VkPhysicalDeviceToolProperties* a,
+                                               const VkPhysicalDeviceToolProperties* b,
+                                               OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* a,
+    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDevicePrivateDataFeatures(const VkPhysicalDevicePrivateDataFeatures* a,
+                                                    const VkPhysicalDevicePrivateDataFeatures* b,
+                                                    OnFailCompareFunc onFail);
+
+void checkEqual_VkDevicePrivateDataCreateInfo(const VkDevicePrivateDataCreateInfo* a,
+                                              const VkDevicePrivateDataCreateInfo* b,
+                                              OnFailCompareFunc onFail);
+
+void checkEqual_VkPrivateDataSlotCreateInfo(const VkPrivateDataSlotCreateInfo* a,
+                                            const VkPrivateDataSlotCreateInfo* b,
+                                            OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    const VkPhysicalDevicePipelineCreationCacheControlFeatures* a,
+    const VkPhysicalDevicePipelineCreationCacheControlFeatures* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkMemoryBarrier2(const VkMemoryBarrier2* a, const VkMemoryBarrier2* b,
+                                 OnFailCompareFunc onFail);
+
+void checkEqual_VkBufferMemoryBarrier2(const VkBufferMemoryBarrier2* a,
+                                       const VkBufferMemoryBarrier2* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkImageMemoryBarrier2(const VkImageMemoryBarrier2* a,
+                                      const VkImageMemoryBarrier2* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkDependencyInfo(const VkDependencyInfo* a, const VkDependencyInfo* b,
+                                 OnFailCompareFunc onFail);
+
+void checkEqual_VkSemaphoreSubmitInfo(const VkSemaphoreSubmitInfo* a,
+                                      const VkSemaphoreSubmitInfo* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkCommandBufferSubmitInfo(const VkCommandBufferSubmitInfo* a,
+                                          const VkCommandBufferSubmitInfo* b,
+                                          OnFailCompareFunc onFail);
+
+void checkEqual_VkSubmitInfo2(const VkSubmitInfo2* a, const VkSubmitInfo2* b,
+                              OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceSynchronization2Features(
+    const VkPhysicalDeviceSynchronization2Features* a,
+    const VkPhysicalDeviceSynchronization2Features* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* a,
+    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceImageRobustnessFeatures(
+    const VkPhysicalDeviceImageRobustnessFeatures* a,
+    const VkPhysicalDeviceImageRobustnessFeatures* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkBufferCopy2(const VkBufferCopy2* a, const VkBufferCopy2* b,
+                              OnFailCompareFunc onFail);
+
+void checkEqual_VkCopyBufferInfo2(const VkCopyBufferInfo2* a, const VkCopyBufferInfo2* b,
+                                  OnFailCompareFunc onFail);
+
+void checkEqual_VkImageCopy2(const VkImageCopy2* a, const VkImageCopy2* b,
+                             OnFailCompareFunc onFail);
+
+void checkEqual_VkCopyImageInfo2(const VkCopyImageInfo2* a, const VkCopyImageInfo2* b,
+                                 OnFailCompareFunc onFail);
+
+void checkEqual_VkBufferImageCopy2(const VkBufferImageCopy2* a, const VkBufferImageCopy2* b,
+                                   OnFailCompareFunc onFail);
+
+void checkEqual_VkCopyBufferToImageInfo2(const VkCopyBufferToImageInfo2* a,
+                                         const VkCopyBufferToImageInfo2* b,
+                                         OnFailCompareFunc onFail);
+
+void checkEqual_VkCopyImageToBufferInfo2(const VkCopyImageToBufferInfo2* a,
+                                         const VkCopyImageToBufferInfo2* b,
+                                         OnFailCompareFunc onFail);
+
+void checkEqual_VkImageBlit2(const VkImageBlit2* a, const VkImageBlit2* b,
+                             OnFailCompareFunc onFail);
+
+void checkEqual_VkBlitImageInfo2(const VkBlitImageInfo2* a, const VkBlitImageInfo2* b,
+                                 OnFailCompareFunc onFail);
+
+void checkEqual_VkImageResolve2(const VkImageResolve2* a, const VkImageResolve2* b,
+                                OnFailCompareFunc onFail);
+
+void checkEqual_VkResolveImageInfo2(const VkResolveImageInfo2* a, const VkResolveImageInfo2* b,
+                                    OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    const VkPhysicalDeviceSubgroupSizeControlFeatures* a,
+    const VkPhysicalDeviceSubgroupSizeControlFeatures* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceSubgroupSizeControlProperties(
+    const VkPhysicalDeviceSubgroupSizeControlProperties* a,
+    const VkPhysicalDeviceSubgroupSizeControlProperties* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* a,
+    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceInlineUniformBlockFeatures(
+    const VkPhysicalDeviceInlineUniformBlockFeatures* a,
+    const VkPhysicalDeviceInlineUniformBlockFeatures* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceInlineUniformBlockProperties(
+    const VkPhysicalDeviceInlineUniformBlockProperties* a,
+    const VkPhysicalDeviceInlineUniformBlockProperties* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkWriteDescriptorSetInlineUniformBlock(
+    const VkWriteDescriptorSetInlineUniformBlock* a,
+    const VkWriteDescriptorSetInlineUniformBlock* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    const VkDescriptorPoolInlineUniformBlockCreateInfo* a,
+    const VkDescriptorPoolInlineUniformBlockCreateInfo* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* a,
+    const VkPhysicalDeviceTextureCompressionASTCHDRFeatures* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkRenderingAttachmentInfo(const VkRenderingAttachmentInfo* a,
+                                          const VkRenderingAttachmentInfo* b,
+                                          OnFailCompareFunc onFail);
+
+void checkEqual_VkRenderingInfo(const VkRenderingInfo* a, const VkRenderingInfo* b,
+                                OnFailCompareFunc onFail);
+
+void checkEqual_VkPipelineRenderingCreateInfo(const VkPipelineRenderingCreateInfo* a,
+                                              const VkPipelineRenderingCreateInfo* b,
+                                              OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceDynamicRenderingFeatures(
+    const VkPhysicalDeviceDynamicRenderingFeatures* a,
+    const VkPhysicalDeviceDynamicRenderingFeatures* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkCommandBufferInheritanceRenderingInfo(
+    const VkCommandBufferInheritanceRenderingInfo* a,
+    const VkCommandBufferInheritanceRenderingInfo* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    const VkPhysicalDeviceShaderIntegerDotProductFeatures* a,
+    const VkPhysicalDeviceShaderIntegerDotProductFeatures* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    const VkPhysicalDeviceShaderIntegerDotProductProperties* a,
+    const VkPhysicalDeviceShaderIntegerDotProductProperties* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    const VkPhysicalDeviceTexelBufferAlignmentProperties* a,
+    const VkPhysicalDeviceTexelBufferAlignmentProperties* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkFormatProperties3(const VkFormatProperties3* a, const VkFormatProperties3* b,
+                                    OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceMaintenance4Features(const VkPhysicalDeviceMaintenance4Features* a,
+                                                     const VkPhysicalDeviceMaintenance4Features* b,
+                                                     OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceMaintenance4Properties(
+    const VkPhysicalDeviceMaintenance4Properties* a,
+    const VkPhysicalDeviceMaintenance4Properties* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirements* a,
+                                                 const VkDeviceBufferMemoryRequirements* b,
+                                                 OnFailCompareFunc onFail);
+
+void checkEqual_VkDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirements* a,
+                                                const VkDeviceImageMemoryRequirements* b,
+                                                OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_KHR_surface
 void checkEqual_VkSurfaceCapabilitiesKHR(const VkSurfaceCapabilitiesKHR* a,
                                          const VkSurfaceCapabilitiesKHR* b,
@@ -983,15 +1180,20 @@ void checkEqual_VkWin32SurfaceCreateInfoKHR(const VkWin32SurfaceCreateInfoKHR* a
 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
 #endif
 #ifdef VK_KHR_video_queue
-void checkEqual_VkVideoQueueFamilyProperties2KHR(const VkVideoQueueFamilyProperties2KHR* a,
-                                                 const VkVideoQueueFamilyProperties2KHR* b,
-                                                 OnFailCompareFunc onFail);
+void checkEqual_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    const VkQueueFamilyQueryResultStatusPropertiesKHR* a,
+    const VkQueueFamilyQueryResultStatusPropertiesKHR* b, OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoProfileKHR(const VkVideoProfileKHR* a, const VkVideoProfileKHR* b,
-                                  OnFailCompareFunc onFail);
+void checkEqual_VkQueueFamilyVideoPropertiesKHR(const VkQueueFamilyVideoPropertiesKHR* a,
+                                                const VkQueueFamilyVideoPropertiesKHR* b,
+                                                OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoProfilesKHR(const VkVideoProfilesKHR* a, const VkVideoProfilesKHR* b,
-                                   OnFailCompareFunc onFail);
+void checkEqual_VkVideoProfileInfoKHR(const VkVideoProfileInfoKHR* a,
+                                      const VkVideoProfileInfoKHR* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoProfileListInfoKHR(const VkVideoProfileListInfoKHR* a,
+                                          const VkVideoProfileListInfoKHR* b,
+                                          OnFailCompareFunc onFail);
 
 void checkEqual_VkVideoCapabilitiesKHR(const VkVideoCapabilitiesKHR* a,
                                        const VkVideoCapabilitiesKHR* b, OnFailCompareFunc onFail);
@@ -1004,19 +1206,21 @@ void checkEqual_VkVideoFormatPropertiesKHR(const VkVideoFormatPropertiesKHR* a,
                                            const VkVideoFormatPropertiesKHR* b,
                                            OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoPictureResourceKHR(const VkVideoPictureResourceKHR* a,
-                                          const VkVideoPictureResourceKHR* b,
-                                          OnFailCompareFunc onFail);
+void checkEqual_VkVideoPictureResourceInfoKHR(const VkVideoPictureResourceInfoKHR* a,
+                                              const VkVideoPictureResourceInfoKHR* b,
+                                              OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoReferenceSlotKHR(const VkVideoReferenceSlotKHR* a,
-                                        const VkVideoReferenceSlotKHR* b, OnFailCompareFunc onFail);
+void checkEqual_VkVideoReferenceSlotInfoKHR(const VkVideoReferenceSlotInfoKHR* a,
+                                            const VkVideoReferenceSlotInfoKHR* b,
+                                            OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoGetMemoryPropertiesKHR(const VkVideoGetMemoryPropertiesKHR* a,
-                                              const VkVideoGetMemoryPropertiesKHR* b,
-                                              OnFailCompareFunc onFail);
+void checkEqual_VkVideoSessionMemoryRequirementsKHR(const VkVideoSessionMemoryRequirementsKHR* a,
+                                                    const VkVideoSessionMemoryRequirementsKHR* b,
+                                                    OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoBindMemoryKHR(const VkVideoBindMemoryKHR* a, const VkVideoBindMemoryKHR* b,
-                                     OnFailCompareFunc onFail);
+void checkEqual_VkBindVideoSessionMemoryInfoKHR(const VkBindVideoSessionMemoryInfoKHR* a,
+                                                const VkBindVideoSessionMemoryInfoKHR* b,
+                                                OnFailCompareFunc onFail);
 
 void checkEqual_VkVideoSessionCreateInfoKHR(const VkVideoSessionCreateInfoKHR* a,
                                             const VkVideoSessionCreateInfoKHR* b,
@@ -1043,29 +1247,57 @@ void checkEqual_VkVideoCodingControlInfoKHR(const VkVideoCodingControlInfoKHR* a
 
 #endif
 #ifdef VK_KHR_video_decode_queue
+void checkEqual_VkVideoDecodeCapabilitiesKHR(const VkVideoDecodeCapabilitiesKHR* a,
+                                             const VkVideoDecodeCapabilitiesKHR* b,
+                                             OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoDecodeUsageInfoKHR(const VkVideoDecodeUsageInfoKHR* a,
+                                          const VkVideoDecodeUsageInfoKHR* b,
+                                          OnFailCompareFunc onFail);
+
 void checkEqual_VkVideoDecodeInfoKHR(const VkVideoDecodeInfoKHR* a, const VkVideoDecodeInfoKHR* b,
                                      OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_KHR_video_decode_h264
+void checkEqual_VkVideoDecodeH264ProfileInfoKHR(const VkVideoDecodeH264ProfileInfoKHR* a,
+                                                const VkVideoDecodeH264ProfileInfoKHR* b,
+                                                OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoDecodeH264CapabilitiesKHR(const VkVideoDecodeH264CapabilitiesKHR* a,
+                                                 const VkVideoDecodeH264CapabilitiesKHR* b,
+                                                 OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    const VkVideoDecodeH264SessionParametersAddInfoKHR* a,
+    const VkVideoDecodeH264SessionParametersAddInfoKHR* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoDecodeH264SessionParametersCreateInfoKHR(
+    const VkVideoDecodeH264SessionParametersCreateInfoKHR* a,
+    const VkVideoDecodeH264SessionParametersCreateInfoKHR* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoDecodeH264PictureInfoKHR(const VkVideoDecodeH264PictureInfoKHR* a,
+                                                const VkVideoDecodeH264PictureInfoKHR* b,
+                                                OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoDecodeH264DpbSlotInfoKHR(const VkVideoDecodeH264DpbSlotInfoKHR* a,
+                                                const VkVideoDecodeH264DpbSlotInfoKHR* b,
+                                                OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_KHR_dynamic_rendering
-void checkEqual_VkRenderingAttachmentInfoKHR(const VkRenderingAttachmentInfoKHR* a,
-                                             const VkRenderingAttachmentInfoKHR* b,
-                                             OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkRenderingInfo, checkEqual_VkRenderingInfoKHR)
 
-void checkEqual_VkRenderingInfoKHR(const VkRenderingInfoKHR* a, const VkRenderingInfoKHR* b,
-                                   OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkRenderingAttachmentInfo, checkEqual_VkRenderingAttachmentInfoKHR)
 
-void checkEqual_VkPipelineRenderingCreateInfoKHR(const VkPipelineRenderingCreateInfoKHR* a,
-                                                 const VkPipelineRenderingCreateInfoKHR* b,
-                                                 OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPipelineRenderingCreateInfo,
+                      checkEqual_VkPipelineRenderingCreateInfoKHR)
 
-void checkEqual_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
-    const VkPhysicalDeviceDynamicRenderingFeaturesKHR* a,
-    const VkPhysicalDeviceDynamicRenderingFeaturesKHR* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceDynamicRenderingFeatures,
+                      checkEqual_VkPhysicalDeviceDynamicRenderingFeaturesKHR)
 
-void checkEqual_VkCommandBufferInheritanceRenderingInfoKHR(
-    const VkCommandBufferInheritanceRenderingInfoKHR* a,
-    const VkCommandBufferInheritanceRenderingInfoKHR* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkCommandBufferInheritanceRenderingInfo,
+                      checkEqual_VkCommandBufferInheritanceRenderingInfoKHR)
 
 void checkEqual_VkRenderingFragmentShadingRateAttachmentInfoKHR(
     const VkRenderingFragmentShadingRateAttachmentInfoKHR* a,
@@ -1560,6 +1792,46 @@ void checkEqual_VkPhysicalDeviceShaderClockFeaturesKHR(
     const VkPhysicalDeviceShaderClockFeaturesKHR* b, OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_KHR_video_decode_h265
+void checkEqual_VkVideoDecodeH265ProfileInfoKHR(const VkVideoDecodeH265ProfileInfoKHR* a,
+                                                const VkVideoDecodeH265ProfileInfoKHR* b,
+                                                OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoDecodeH265CapabilitiesKHR(const VkVideoDecodeH265CapabilitiesKHR* a,
+                                                 const VkVideoDecodeH265CapabilitiesKHR* b,
+                                                 OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    const VkVideoDecodeH265SessionParametersAddInfoKHR* a,
+    const VkVideoDecodeH265SessionParametersAddInfoKHR* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    const VkVideoDecodeH265SessionParametersCreateInfoKHR* a,
+    const VkVideoDecodeH265SessionParametersCreateInfoKHR* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoDecodeH265PictureInfoKHR(const VkVideoDecodeH265PictureInfoKHR* a,
+                                                const VkVideoDecodeH265PictureInfoKHR* b,
+                                                OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoDecodeH265DpbSlotInfoKHR(const VkVideoDecodeH265DpbSlotInfoKHR* a,
+                                                const VkVideoDecodeH265DpbSlotInfoKHR* b,
+                                                OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_KHR_global_priority
+void checkEqual_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    const VkDeviceQueueGlobalPriorityCreateInfoKHR* a,
+    const VkDeviceQueueGlobalPriorityCreateInfoKHR* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* a,
+    const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    const VkQueueFamilyGlobalPriorityPropertiesKHR* a,
+    const VkQueueFamilyGlobalPriorityPropertiesKHR* b, OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_KHR_driver_properties
 DEFINE_ALIAS_FUNCTION(checkEqual_VkConformanceVersion, checkEqual_VkConformanceVersionKHR)
 
@@ -1605,9 +1877,8 @@ DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceVulkanMemoryModelFeatures,
 
 #endif
 #ifdef VK_KHR_shader_terminate_invocation
-void checkEqual_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
-    const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* a,
-    const VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceShaderTerminateInvocationFeatures,
+                      checkEqual_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)
 
 #endif
 #ifdef VK_KHR_fragment_shading_rate
@@ -1709,14 +1980,20 @@ void checkEqual_VkPipelineExecutableInternalRepresentationKHR(
     const VkPipelineExecutableInternalRepresentationKHR* b, OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_KHR_map_memory2
+void checkEqual_VkMemoryMapInfoKHR(const VkMemoryMapInfoKHR* a, const VkMemoryMapInfoKHR* b,
+                                   OnFailCompareFunc onFail);
+
+void checkEqual_VkMemoryUnmapInfoKHR(const VkMemoryUnmapInfoKHR* a, const VkMemoryUnmapInfoKHR* b,
+                                     OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
-void checkEqual_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* a,
-    const VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceShaderIntegerDotProductFeatures,
+                      checkEqual_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR)
 
-void checkEqual_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* a,
-    const VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceShaderIntegerDotProductProperties,
+                      checkEqual_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)
 
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -1740,40 +2017,44 @@ void checkEqual_VkPhysicalDevicePresentIdFeaturesKHR(const VkPhysicalDevicePrese
 void checkEqual_VkVideoEncodeInfoKHR(const VkVideoEncodeInfoKHR* a, const VkVideoEncodeInfoKHR* b,
                                      OnFailCompareFunc onFail);
 
+void checkEqual_VkVideoEncodeCapabilitiesKHR(const VkVideoEncodeCapabilitiesKHR* a,
+                                             const VkVideoEncodeCapabilitiesKHR* b,
+                                             OnFailCompareFunc onFail);
+
+void checkEqual_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* a,
+    const VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoEncodeUsageInfoKHR(const VkVideoEncodeUsageInfoKHR* a,
+                                          const VkVideoEncodeUsageInfoKHR* b,
+                                          OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoEncodeRateControlLayerInfoKHR(const VkVideoEncodeRateControlLayerInfoKHR* a,
+                                                     const VkVideoEncodeRateControlLayerInfoKHR* b,
+                                                     OnFailCompareFunc onFail);
+
 void checkEqual_VkVideoEncodeRateControlInfoKHR(const VkVideoEncodeRateControlInfoKHR* a,
                                                 const VkVideoEncodeRateControlInfoKHR* b,
                                                 OnFailCompareFunc onFail);
 
 #endif
 #ifdef VK_KHR_synchronization2
-void checkEqual_VkMemoryBarrier2KHR(const VkMemoryBarrier2KHR* a, const VkMemoryBarrier2KHR* b,
-                                    OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkMemoryBarrier2, checkEqual_VkMemoryBarrier2KHR)
 
-void checkEqual_VkBufferMemoryBarrier2KHR(const VkBufferMemoryBarrier2KHR* a,
-                                          const VkBufferMemoryBarrier2KHR* b,
-                                          OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkBufferMemoryBarrier2, checkEqual_VkBufferMemoryBarrier2KHR)
 
-void checkEqual_VkImageMemoryBarrier2KHR(const VkImageMemoryBarrier2KHR* a,
-                                         const VkImageMemoryBarrier2KHR* b,
-                                         OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkImageMemoryBarrier2, checkEqual_VkImageMemoryBarrier2KHR)
 
-void checkEqual_VkDependencyInfoKHR(const VkDependencyInfoKHR* a, const VkDependencyInfoKHR* b,
-                                    OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkDependencyInfo, checkEqual_VkDependencyInfoKHR)
 
-void checkEqual_VkSemaphoreSubmitInfoKHR(const VkSemaphoreSubmitInfoKHR* a,
-                                         const VkSemaphoreSubmitInfoKHR* b,
-                                         OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkSubmitInfo2, checkEqual_VkSubmitInfo2KHR)
 
-void checkEqual_VkCommandBufferSubmitInfoKHR(const VkCommandBufferSubmitInfoKHR* a,
-                                             const VkCommandBufferSubmitInfoKHR* b,
-                                             OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkSemaphoreSubmitInfo, checkEqual_VkSemaphoreSubmitInfoKHR)
 
-void checkEqual_VkSubmitInfo2KHR(const VkSubmitInfo2KHR* a, const VkSubmitInfo2KHR* b,
-                                 OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkCommandBufferSubmitInfo, checkEqual_VkCommandBufferSubmitInfoKHR)
 
-void checkEqual_VkPhysicalDeviceSynchronization2FeaturesKHR(
-    const VkPhysicalDeviceSynchronization2FeaturesKHR* a,
-    const VkPhysicalDeviceSynchronization2FeaturesKHR* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceSynchronization2Features,
+                      checkEqual_VkPhysicalDeviceSynchronization2FeaturesKHR)
 
 void checkEqual_VkQueueFamilyCheckpointProperties2NV(const VkQueueFamilyCheckpointProperties2NV* a,
                                                      const VkQueueFamilyCheckpointProperties2NV* b,
@@ -1783,6 +2064,16 @@ void checkEqual_VkCheckpointData2NV(const VkCheckpointData2NV* a, const VkCheckp
                                     OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+void checkEqual_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* a,
+    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* a,
+    const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* b, OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 void checkEqual_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
     const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR* a,
@@ -1790,9 +2081,8 @@ void checkEqual_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
-void checkEqual_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* a,
-    const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
+                      checkEqual_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR)
 
 #endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
@@ -1802,69 +2092,81 @@ void checkEqual_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
 
 #endif
 #ifdef VK_KHR_copy_commands2
-void checkEqual_VkBufferCopy2KHR(const VkBufferCopy2KHR* a, const VkBufferCopy2KHR* b,
-                                 OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkCopyBufferInfo2, checkEqual_VkCopyBufferInfo2KHR)
 
-void checkEqual_VkCopyBufferInfo2KHR(const VkCopyBufferInfo2KHR* a, const VkCopyBufferInfo2KHR* b,
-                                     OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkCopyImageInfo2, checkEqual_VkCopyImageInfo2KHR)
 
-void checkEqual_VkImageCopy2KHR(const VkImageCopy2KHR* a, const VkImageCopy2KHR* b,
-                                OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkCopyBufferToImageInfo2, checkEqual_VkCopyBufferToImageInfo2KHR)
 
-void checkEqual_VkCopyImageInfo2KHR(const VkCopyImageInfo2KHR* a, const VkCopyImageInfo2KHR* b,
-                                    OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkCopyImageToBufferInfo2, checkEqual_VkCopyImageToBufferInfo2KHR)
 
-void checkEqual_VkBufferImageCopy2KHR(const VkBufferImageCopy2KHR* a,
-                                      const VkBufferImageCopy2KHR* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkBlitImageInfo2, checkEqual_VkBlitImageInfo2KHR)
 
-void checkEqual_VkCopyBufferToImageInfo2KHR(const VkCopyBufferToImageInfo2KHR* a,
-                                            const VkCopyBufferToImageInfo2KHR* b,
-                                            OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkResolveImageInfo2, checkEqual_VkResolveImageInfo2KHR)
 
-void checkEqual_VkCopyImageToBufferInfo2KHR(const VkCopyImageToBufferInfo2KHR* a,
-                                            const VkCopyImageToBufferInfo2KHR* b,
-                                            OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkBufferCopy2, checkEqual_VkBufferCopy2KHR)
 
-void checkEqual_VkImageBlit2KHR(const VkImageBlit2KHR* a, const VkImageBlit2KHR* b,
-                                OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkImageCopy2, checkEqual_VkImageCopy2KHR)
 
-void checkEqual_VkBlitImageInfo2KHR(const VkBlitImageInfo2KHR* a, const VkBlitImageInfo2KHR* b,
-                                    OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkImageBlit2, checkEqual_VkImageBlit2KHR)
 
-void checkEqual_VkImageResolve2KHR(const VkImageResolve2KHR* a, const VkImageResolve2KHR* b,
-                                   OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkBufferImageCopy2, checkEqual_VkBufferImageCopy2KHR)
 
-void checkEqual_VkResolveImageInfo2KHR(const VkResolveImageInfo2KHR* a,
-                                       const VkResolveImageInfo2KHR* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkImageResolve2, checkEqual_VkImageResolve2KHR)
 
 #endif
 #ifdef VK_KHR_format_feature_flags2
-void checkEqual_VkFormatProperties3KHR(const VkFormatProperties3KHR* a,
-                                       const VkFormatProperties3KHR* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkFormatProperties3, checkEqual_VkFormatProperties3KHR)
+
+#endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+void checkEqual_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* a,
+    const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkTraceRaysIndirectCommand2KHR(const VkTraceRaysIndirectCommand2KHR* a,
+                                               const VkTraceRaysIndirectCommand2KHR* b,
+                                               OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
-void checkEqual_VkPhysicalDeviceMaintenance4FeaturesKHR(
-    const VkPhysicalDeviceMaintenance4FeaturesKHR* a,
-    const VkPhysicalDeviceMaintenance4FeaturesKHR* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceMaintenance4Features,
+                      checkEqual_VkPhysicalDeviceMaintenance4FeaturesKHR)
 
-void checkEqual_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    const VkPhysicalDeviceMaintenance4PropertiesKHR* a,
-    const VkPhysicalDeviceMaintenance4PropertiesKHR* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceMaintenance4Properties,
+                      checkEqual_VkPhysicalDeviceMaintenance4PropertiesKHR)
 
-void checkEqual_VkDeviceBufferMemoryRequirementsKHR(const VkDeviceBufferMemoryRequirementsKHR* a,
-                                                    const VkDeviceBufferMemoryRequirementsKHR* b,
-                                                    OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkDeviceBufferMemoryRequirements,
+                      checkEqual_VkDeviceBufferMemoryRequirementsKHR)
 
-void checkEqual_VkDeviceImageMemoryRequirementsKHR(const VkDeviceImageMemoryRequirementsKHR* a,
-                                                   const VkDeviceImageMemoryRequirementsKHR* b,
-                                                   OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkDeviceImageMemoryRequirements,
+                      checkEqual_VkDeviceImageMemoryRequirementsKHR)
+
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+void checkEqual_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* a,
+    const VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* b, OnFailCompareFunc onFail);
 
 #endif
 #ifdef VK_ANDROID_native_buffer
+void checkEqual_VkNativeBufferUsage2ANDROID(const VkNativeBufferUsage2ANDROID* a,
+                                            const VkNativeBufferUsage2ANDROID* b,
+                                            OnFailCompareFunc onFail);
+
 void checkEqual_VkNativeBufferANDROID(const VkNativeBufferANDROID* a,
                                       const VkNativeBufferANDROID* b, OnFailCompareFunc onFail);
 
+void checkEqual_VkSwapchainImageCreateInfoANDROID(const VkSwapchainImageCreateInfoANDROID* a,
+                                                  const VkSwapchainImageCreateInfoANDROID* b,
+                                                  OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDevicePresentationPropertiesANDROID(
+    const VkPhysicalDevicePresentationPropertiesANDROID* a,
+    const VkPhysicalDevicePresentationPropertiesANDROID* b, OnFailCompareFunc onFail);
+
 #endif
 #ifdef VK_EXT_debug_report
 void checkEqual_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* a,
@@ -1967,10 +2269,6 @@ void checkEqual_VkVideoEncodeH264CapabilitiesEXT(const VkVideoEncodeH264Capabili
                                                  const VkVideoEncodeH264CapabilitiesEXT* b,
                                                  OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoEncodeH264SessionCreateInfoEXT(
-    const VkVideoEncodeH264SessionCreateInfoEXT* a, const VkVideoEncodeH264SessionCreateInfoEXT* b,
-    OnFailCompareFunc onFail);
-
 void checkEqual_VkVideoEncodeH264SessionParametersAddInfoEXT(
     const VkVideoEncodeH264SessionParametersAddInfoEXT* a,
     const VkVideoEncodeH264SessionParametersAddInfoEXT* b, OnFailCompareFunc onFail);
@@ -1979,25 +2277,36 @@ void checkEqual_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     const VkVideoEncodeH264SessionParametersCreateInfoEXT* a,
     const VkVideoEncodeH264SessionParametersCreateInfoEXT* b, OnFailCompareFunc onFail);
 
+void checkEqual_VkVideoEncodeH264NaluSliceInfoEXT(const VkVideoEncodeH264NaluSliceInfoEXT* a,
+                                                  const VkVideoEncodeH264NaluSliceInfoEXT* b,
+                                                  OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoEncodeH264VclFrameInfoEXT(const VkVideoEncodeH264VclFrameInfoEXT* a,
+                                                 const VkVideoEncodeH264VclFrameInfoEXT* b,
+                                                 OnFailCompareFunc onFail);
+
 void checkEqual_VkVideoEncodeH264DpbSlotInfoEXT(const VkVideoEncodeH264DpbSlotInfoEXT* a,
                                                 const VkVideoEncodeH264DpbSlotInfoEXT* b,
                                                 OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoEncodeH264NaluSliceEXT(const VkVideoEncodeH264NaluSliceEXT* a,
-                                              const VkVideoEncodeH264NaluSliceEXT* b,
-                                              OnFailCompareFunc onFail);
+void checkEqual_VkVideoEncodeH264ProfileInfoEXT(const VkVideoEncodeH264ProfileInfoEXT* a,
+                                                const VkVideoEncodeH264ProfileInfoEXT* b,
+                                                OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoEncodeH264VclFrameInfoEXT(const VkVideoEncodeH264VclFrameInfoEXT* a,
-                                                 const VkVideoEncodeH264VclFrameInfoEXT* b,
-                                                 OnFailCompareFunc onFail);
+void checkEqual_VkVideoEncodeH264RateControlInfoEXT(const VkVideoEncodeH264RateControlInfoEXT* a,
+                                                    const VkVideoEncodeH264RateControlInfoEXT* b,
+                                                    OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoEncodeH264EmitPictureParametersEXT(
-    const VkVideoEncodeH264EmitPictureParametersEXT* a,
-    const VkVideoEncodeH264EmitPictureParametersEXT* b, OnFailCompareFunc onFail);
+void checkEqual_VkVideoEncodeH264QpEXT(const VkVideoEncodeH264QpEXT* a,
+                                       const VkVideoEncodeH264QpEXT* b, OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoEncodeH264ProfileEXT(const VkVideoEncodeH264ProfileEXT* a,
-                                            const VkVideoEncodeH264ProfileEXT* b,
-                                            OnFailCompareFunc onFail);
+void checkEqual_VkVideoEncodeH264FrameSizeEXT(const VkVideoEncodeH264FrameSizeEXT* a,
+                                              const VkVideoEncodeH264FrameSizeEXT* b,
+                                              OnFailCompareFunc onFail);
+
+void checkEqual_VkVideoEncodeH264RateControlLayerInfoEXT(
+    const VkVideoEncodeH264RateControlLayerInfoEXT* a,
+    const VkVideoEncodeH264RateControlLayerInfoEXT* b, OnFailCompareFunc onFail);
 
 #endif
 #ifdef VK_EXT_video_encode_h265
@@ -2005,10 +2314,6 @@ void checkEqual_VkVideoEncodeH265CapabilitiesEXT(const VkVideoEncodeH265Capabili
                                                  const VkVideoEncodeH265CapabilitiesEXT* b,
                                                  OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoEncodeH265SessionCreateInfoEXT(
-    const VkVideoEncodeH265SessionCreateInfoEXT* a, const VkVideoEncodeH265SessionCreateInfoEXT* b,
-    OnFailCompareFunc onFail);
-
 void checkEqual_VkVideoEncodeH265SessionParametersAddInfoEXT(
     const VkVideoEncodeH265SessionParametersAddInfoEXT* a,
     const VkVideoEncodeH265SessionParametersAddInfoEXT* b, OnFailCompareFunc onFail);
@@ -2017,62 +2322,36 @@ void checkEqual_VkVideoEncodeH265SessionParametersCreateInfoEXT(
     const VkVideoEncodeH265SessionParametersCreateInfoEXT* a,
     const VkVideoEncodeH265SessionParametersCreateInfoEXT* b, OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoEncodeH265DpbSlotInfoEXT(const VkVideoEncodeH265DpbSlotInfoEXT* a,
-                                                const VkVideoEncodeH265DpbSlotInfoEXT* b,
-                                                OnFailCompareFunc onFail);
-
-void checkEqual_VkVideoEncodeH265ReferenceListsEXT(const VkVideoEncodeH265ReferenceListsEXT* a,
-                                                   const VkVideoEncodeH265ReferenceListsEXT* b,
-                                                   OnFailCompareFunc onFail);
-
-void checkEqual_VkVideoEncodeH265NaluSliceEXT(const VkVideoEncodeH265NaluSliceEXT* a,
-                                              const VkVideoEncodeH265NaluSliceEXT* b,
-                                              OnFailCompareFunc onFail);
+void checkEqual_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+    const VkVideoEncodeH265NaluSliceSegmentInfoEXT* a,
+    const VkVideoEncodeH265NaluSliceSegmentInfoEXT* b, OnFailCompareFunc onFail);
 
 void checkEqual_VkVideoEncodeH265VclFrameInfoEXT(const VkVideoEncodeH265VclFrameInfoEXT* a,
                                                  const VkVideoEncodeH265VclFrameInfoEXT* b,
                                                  OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoEncodeH265EmitPictureParametersEXT(
-    const VkVideoEncodeH265EmitPictureParametersEXT* a,
-    const VkVideoEncodeH265EmitPictureParametersEXT* b, OnFailCompareFunc onFail);
-
-void checkEqual_VkVideoEncodeH265ProfileEXT(const VkVideoEncodeH265ProfileEXT* a,
-                                            const VkVideoEncodeH265ProfileEXT* b,
-                                            OnFailCompareFunc onFail);
-
-#endif
-#ifdef VK_EXT_video_decode_h264
-void checkEqual_VkVideoDecodeH264ProfileEXT(const VkVideoDecodeH264ProfileEXT* a,
-                                            const VkVideoDecodeH264ProfileEXT* b,
-                                            OnFailCompareFunc onFail);
-
-void checkEqual_VkVideoDecodeH264CapabilitiesEXT(const VkVideoDecodeH264CapabilitiesEXT* a,
-                                                 const VkVideoDecodeH264CapabilitiesEXT* b,
-                                                 OnFailCompareFunc onFail);
-
-void checkEqual_VkVideoDecodeH264SessionCreateInfoEXT(
-    const VkVideoDecodeH264SessionCreateInfoEXT* a, const VkVideoDecodeH264SessionCreateInfoEXT* b,
-    OnFailCompareFunc onFail);
+void checkEqual_VkVideoEncodeH265DpbSlotInfoEXT(const VkVideoEncodeH265DpbSlotInfoEXT* a,
+                                                const VkVideoEncodeH265DpbSlotInfoEXT* b,
+                                                OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    const VkVideoDecodeH264SessionParametersAddInfoEXT* a,
-    const VkVideoDecodeH264SessionParametersAddInfoEXT* b, OnFailCompareFunc onFail);
+void checkEqual_VkVideoEncodeH265ProfileInfoEXT(const VkVideoEncodeH265ProfileInfoEXT* a,
+                                                const VkVideoEncodeH265ProfileInfoEXT* b,
+                                                OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-    const VkVideoDecodeH264SessionParametersCreateInfoEXT* a,
-    const VkVideoDecodeH264SessionParametersCreateInfoEXT* b, OnFailCompareFunc onFail);
+void checkEqual_VkVideoEncodeH265RateControlInfoEXT(const VkVideoEncodeH265RateControlInfoEXT* a,
+                                                    const VkVideoEncodeH265RateControlInfoEXT* b,
+                                                    OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoDecodeH264PictureInfoEXT(const VkVideoDecodeH264PictureInfoEXT* a,
-                                                const VkVideoDecodeH264PictureInfoEXT* b,
-                                                OnFailCompareFunc onFail);
+void checkEqual_VkVideoEncodeH265QpEXT(const VkVideoEncodeH265QpEXT* a,
+                                       const VkVideoEncodeH265QpEXT* b, OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoDecodeH264MvcEXT(const VkVideoDecodeH264MvcEXT* a,
-                                        const VkVideoDecodeH264MvcEXT* b, OnFailCompareFunc onFail);
+void checkEqual_VkVideoEncodeH265FrameSizeEXT(const VkVideoEncodeH265FrameSizeEXT* a,
+                                              const VkVideoEncodeH265FrameSizeEXT* b,
+                                              OnFailCompareFunc onFail);
 
-void checkEqual_VkVideoDecodeH264DpbSlotInfoEXT(const VkVideoDecodeH264DpbSlotInfoEXT* a,
-                                                const VkVideoDecodeH264DpbSlotInfoEXT* b,
-                                                OnFailCompareFunc onFail);
+void checkEqual_VkVideoEncodeH265RateControlLayerInfoEXT(
+    const VkVideoEncodeH265RateControlLayerInfoEXT* a,
+    const VkVideoEncodeH265RateControlLayerInfoEXT* b, OnFailCompareFunc onFail);
 
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
@@ -2154,9 +2433,8 @@ void checkEqual_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* a,
 #ifdef VK_EXT_shader_subgroup_vote
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
-void checkEqual_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-    const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* a,
-    const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceTextureCompressionASTCHDRFeatures,
+                      checkEqual_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
 
 #endif
 #ifdef VK_EXT_astc_decode_mode
@@ -2169,6 +2447,20 @@ void checkEqual_VkPhysicalDeviceASTCDecodeFeaturesEXT(
     OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_EXT_pipeline_robustness
+void checkEqual_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* a,
+    const VkPhysicalDevicePipelineRobustnessFeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* a,
+    const VkPhysicalDevicePipelineRobustnessPropertiesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPipelineRobustnessCreateInfoEXT(const VkPipelineRobustnessCreateInfoEXT* a,
+                                                  const VkPipelineRobustnessCreateInfoEXT* b,
+                                                  OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_EXT_conditional_rendering
 void checkEqual_VkConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT* a,
                                                    const VkConditionalRenderingBeginInfoEXT* b,
@@ -2307,8 +2599,6 @@ void checkEqual_VkMacOSSurfaceCreateInfoMVK(const VkMacOSSurfaceCreateInfoMVK* a
                                             OnFailCompareFunc onFail);
 
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -2378,21 +2668,17 @@ DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceSamplerFilterMinmaxProperties,
 #ifdef VK_AMD_shader_fragment_mask
 #endif
 #ifdef VK_EXT_inline_uniform_block
-void checkEqual_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* a,
-    const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceInlineUniformBlockFeatures,
+                      checkEqual_VkPhysicalDeviceInlineUniformBlockFeaturesEXT)
 
-void checkEqual_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* a,
-    const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceInlineUniformBlockProperties,
+                      checkEqual_VkPhysicalDeviceInlineUniformBlockPropertiesEXT)
 
-void checkEqual_VkWriteDescriptorSetInlineUniformBlockEXT(
-    const VkWriteDescriptorSetInlineUniformBlockEXT* a,
-    const VkWriteDescriptorSetInlineUniformBlockEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkWriteDescriptorSetInlineUniformBlock,
+                      checkEqual_VkWriteDescriptorSetInlineUniformBlockEXT)
 
-void checkEqual_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* a,
-    const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkDescriptorPoolInlineUniformBlockCreateInfo,
+                      checkEqual_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_shader_stencil_export
@@ -2648,9 +2934,8 @@ void checkEqual_VkFilterCubicImageViewImageFormatPropertiesEXT(
 #ifdef VK_QCOM_render_pass_shader_resolve
 #endif
 #ifdef VK_EXT_global_priority
-void checkEqual_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    const VkDeviceQueueGlobalPriorityCreateInfoEXT* a,
-    const VkDeviceQueueGlobalPriorityCreateInfoEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkDeviceQueueGlobalPriorityCreateInfoKHR,
+                      checkEqual_VkDeviceQueueGlobalPriorityCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_external_memory_host
@@ -2687,36 +2972,6 @@ void checkEqual_VkPhysicalDeviceShaderCorePropertiesAMD(
     const VkPhysicalDeviceShaderCorePropertiesAMD* b, OnFailCompareFunc onFail);
 
 #endif
-#ifdef VK_EXT_video_decode_h265
-void checkEqual_VkVideoDecodeH265ProfileEXT(const VkVideoDecodeH265ProfileEXT* a,
-                                            const VkVideoDecodeH265ProfileEXT* b,
-                                            OnFailCompareFunc onFail);
-
-void checkEqual_VkVideoDecodeH265CapabilitiesEXT(const VkVideoDecodeH265CapabilitiesEXT* a,
-                                                 const VkVideoDecodeH265CapabilitiesEXT* b,
-                                                 OnFailCompareFunc onFail);
-
-void checkEqual_VkVideoDecodeH265SessionCreateInfoEXT(
-    const VkVideoDecodeH265SessionCreateInfoEXT* a, const VkVideoDecodeH265SessionCreateInfoEXT* b,
-    OnFailCompareFunc onFail);
-
-void checkEqual_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    const VkVideoDecodeH265SessionParametersAddInfoEXT* a,
-    const VkVideoDecodeH265SessionParametersAddInfoEXT* b, OnFailCompareFunc onFail);
-
-void checkEqual_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    const VkVideoDecodeH265SessionParametersCreateInfoEXT* a,
-    const VkVideoDecodeH265SessionParametersCreateInfoEXT* b, OnFailCompareFunc onFail);
-
-void checkEqual_VkVideoDecodeH265PictureInfoEXT(const VkVideoDecodeH265PictureInfoEXT* a,
-                                                const VkVideoDecodeH265PictureInfoEXT* b,
-                                                OnFailCompareFunc onFail);
-
-void checkEqual_VkVideoDecodeH265DpbSlotInfoEXT(const VkVideoDecodeH265DpbSlotInfoEXT* a,
-                                                const VkVideoDecodeH265DpbSlotInfoEXT* b,
-                                                OnFailCompareFunc onFail);
-
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 void checkEqual_VkDeviceMemoryOverallocationCreateInfoAMD(
     const VkDeviceMemoryOverallocationCreateInfoAMD* a,
@@ -2747,13 +3002,11 @@ void checkEqual_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP* a,
 
 #endif
 #ifdef VK_EXT_pipeline_creation_feedback
-void checkEqual_VkPipelineCreationFeedbackEXT(const VkPipelineCreationFeedbackEXT* a,
-                                              const VkPipelineCreationFeedbackEXT* b,
-                                              OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPipelineCreationFeedbackCreateInfo,
+                      checkEqual_VkPipelineCreationFeedbackCreateInfoEXT)
 
-void checkEqual_VkPipelineCreationFeedbackCreateInfoEXT(
-    const VkPipelineCreationFeedbackCreateInfoEXT* a,
-    const VkPipelineCreationFeedbackCreateInfoEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPipelineCreationFeedback,
+                      checkEqual_VkPipelineCreationFeedbackEXT)
 
 #endif
 #ifdef VK_NV_shader_subgroup_partitioned
@@ -2779,9 +3032,8 @@ void checkEqual_VkDrawMeshTasksIndirectCommandNV(const VkDrawMeshTasksIndirectCo
 
 #endif
 #ifdef VK_NV_fragment_shader_barycentric
-void checkEqual_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* a,
-    const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
+                      checkEqual_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV)
 
 #endif
 #ifdef VK_NV_shader_image_footprint
@@ -2903,17 +3155,14 @@ DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceScalarBlockLayoutFeatures,
 #ifdef VK_GOOGLE_decorate_string
 #endif
 #ifdef VK_EXT_subgroup_size_control
-void checkEqual_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* a,
-    const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceSubgroupSizeControlFeatures,
+                      checkEqual_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)
 
-void checkEqual_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* a,
-    const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceSubgroupSizeControlProperties,
+                      checkEqual_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT)
 
-void checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* a,
-    const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)
 
 #endif
 #ifdef VK_AMD_shader_core_properties2
@@ -2972,9 +3221,8 @@ void checkEqual_VkBufferDeviceAddressCreateInfoEXT(const VkBufferDeviceAddressCr
 
 #endif
 #ifdef VK_EXT_tooling_info
-void checkEqual_VkPhysicalDeviceToolPropertiesEXT(const VkPhysicalDeviceToolPropertiesEXT* a,
-                                                  const VkPhysicalDeviceToolPropertiesEXT* b,
-                                                  OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceToolProperties,
+                      checkEqual_VkPhysicalDeviceToolPropertiesEXT)
 
 #endif
 #ifdef VK_EXT_separate_stencil_usage
@@ -3104,10 +3352,48 @@ void checkEqual_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
     const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* b, OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_EXT_surface_maintenance1
+void checkEqual_VkSurfacePresentModeEXT(const VkSurfacePresentModeEXT* a,
+                                        const VkSurfacePresentModeEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkSurfacePresentScalingCapabilitiesEXT(
+    const VkSurfacePresentScalingCapabilitiesEXT* a,
+    const VkSurfacePresentScalingCapabilitiesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkSurfacePresentModeCompatibilityEXT(const VkSurfacePresentModeCompatibilityEXT* a,
+                                                     const VkSurfacePresentModeCompatibilityEXT* b,
+                                                     OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+void checkEqual_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* a,
+    const VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkSwapchainPresentFenceInfoEXT(const VkSwapchainPresentFenceInfoEXT* a,
+                                               const VkSwapchainPresentFenceInfoEXT* b,
+                                               OnFailCompareFunc onFail);
+
+void checkEqual_VkSwapchainPresentModesCreateInfoEXT(const VkSwapchainPresentModesCreateInfoEXT* a,
+                                                     const VkSwapchainPresentModesCreateInfoEXT* b,
+                                                     OnFailCompareFunc onFail);
+
+void checkEqual_VkSwapchainPresentModeInfoEXT(const VkSwapchainPresentModeInfoEXT* a,
+                                              const VkSwapchainPresentModeInfoEXT* b,
+                                              OnFailCompareFunc onFail);
+
+void checkEqual_VkSwapchainPresentScalingCreateInfoEXT(
+    const VkSwapchainPresentScalingCreateInfoEXT* a,
+    const VkSwapchainPresentScalingCreateInfoEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkReleaseSwapchainImagesInfoEXT(const VkReleaseSwapchainImagesInfoEXT* a,
+                                                const VkReleaseSwapchainImagesInfoEXT* b,
+                                                OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_EXT_shader_demote_to_helper_invocation
-void checkEqual_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
-    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* a,
-    const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures,
+                      checkEqual_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)
 
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -3179,9 +3465,8 @@ void checkEqual_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
     const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* a,
     const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* b, OnFailCompareFunc onFail);
 
-void checkEqual_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* a,
-    const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceTexelBufferAlignmentProperties,
+                      checkEqual_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)
 
 #endif
 #ifdef VK_QCOM_render_pass_transform
@@ -3236,24 +3521,34 @@ void checkEqual_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+void checkEqual_VkPhysicalDevicePresentBarrierFeaturesNV(
+    const VkPhysicalDevicePresentBarrierFeaturesNV* a,
+    const VkPhysicalDevicePresentBarrierFeaturesNV* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkSurfaceCapabilitiesPresentBarrierNV(
+    const VkSurfaceCapabilitiesPresentBarrierNV* a, const VkSurfaceCapabilitiesPresentBarrierNV* b,
+    OnFailCompareFunc onFail);
+
+void checkEqual_VkSwapchainPresentBarrierCreateInfoNV(
+    const VkSwapchainPresentBarrierCreateInfoNV* a, const VkSwapchainPresentBarrierCreateInfoNV* b,
+    OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_EXT_private_data
-void checkEqual_VkPhysicalDevicePrivateDataFeaturesEXT(
-    const VkPhysicalDevicePrivateDataFeaturesEXT* a,
-    const VkPhysicalDevicePrivateDataFeaturesEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDevicePrivateDataFeatures,
+                      checkEqual_VkPhysicalDevicePrivateDataFeaturesEXT)
 
-void checkEqual_VkDevicePrivateDataCreateInfoEXT(const VkDevicePrivateDataCreateInfoEXT* a,
-                                                 const VkDevicePrivateDataCreateInfoEXT* b,
-                                                 OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkDevicePrivateDataCreateInfo,
+                      checkEqual_VkDevicePrivateDataCreateInfoEXT)
 
-void checkEqual_VkPrivateDataSlotCreateInfoEXT(const VkPrivateDataSlotCreateInfoEXT* a,
-                                               const VkPrivateDataSlotCreateInfoEXT* b,
-                                               OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPrivateDataSlotCreateInfo,
+                      checkEqual_VkPrivateDataSlotCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
-void checkEqual_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
-    const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* a,
-    const VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDevicePipelineCreationCacheControlFeatures,
+                      checkEqual_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT)
 
 #endif
 #ifdef VK_NV_device_diagnostics_config
@@ -3268,6 +3563,138 @@ void checkEqual_VkDeviceDiagnosticsConfigCreateInfoNV(
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+void checkEqual_VkQueryLowLatencySupportNV(const VkQueryLowLatencySupportNV* a,
+                                           const VkQueryLowLatencySupportNV* b,
+                                           OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_metal_objects
+void checkEqual_VkExportMetalObjectCreateInfoEXT(const VkExportMetalObjectCreateInfoEXT* a,
+                                                 const VkExportMetalObjectCreateInfoEXT* b,
+                                                 OnFailCompareFunc onFail);
+
+void checkEqual_VkExportMetalObjectsInfoEXT(const VkExportMetalObjectsInfoEXT* a,
+                                            const VkExportMetalObjectsInfoEXT* b,
+                                            OnFailCompareFunc onFail);
+
+void checkEqual_VkExportMetalDeviceInfoEXT(const VkExportMetalDeviceInfoEXT* a,
+                                           const VkExportMetalDeviceInfoEXT* b,
+                                           OnFailCompareFunc onFail);
+
+void checkEqual_VkExportMetalCommandQueueInfoEXT(const VkExportMetalCommandQueueInfoEXT* a,
+                                                 const VkExportMetalCommandQueueInfoEXT* b,
+                                                 OnFailCompareFunc onFail);
+
+void checkEqual_VkExportMetalBufferInfoEXT(const VkExportMetalBufferInfoEXT* a,
+                                           const VkExportMetalBufferInfoEXT* b,
+                                           OnFailCompareFunc onFail);
+
+void checkEqual_VkImportMetalBufferInfoEXT(const VkImportMetalBufferInfoEXT* a,
+                                           const VkImportMetalBufferInfoEXT* b,
+                                           OnFailCompareFunc onFail);
+
+void checkEqual_VkExportMetalTextureInfoEXT(const VkExportMetalTextureInfoEXT* a,
+                                            const VkExportMetalTextureInfoEXT* b,
+                                            OnFailCompareFunc onFail);
+
+void checkEqual_VkImportMetalTextureInfoEXT(const VkImportMetalTextureInfoEXT* a,
+                                            const VkImportMetalTextureInfoEXT* b,
+                                            OnFailCompareFunc onFail);
+
+void checkEqual_VkExportMetalIOSurfaceInfoEXT(const VkExportMetalIOSurfaceInfoEXT* a,
+                                              const VkExportMetalIOSurfaceInfoEXT* b,
+                                              OnFailCompareFunc onFail);
+
+void checkEqual_VkImportMetalIOSurfaceInfoEXT(const VkImportMetalIOSurfaceInfoEXT* a,
+                                              const VkImportMetalIOSurfaceInfoEXT* b,
+                                              OnFailCompareFunc onFail);
+
+void checkEqual_VkExportMetalSharedEventInfoEXT(const VkExportMetalSharedEventInfoEXT* a,
+                                                const VkExportMetalSharedEventInfoEXT* b,
+                                                OnFailCompareFunc onFail);
+
+void checkEqual_VkImportMetalSharedEventInfoEXT(const VkImportMetalSharedEventInfoEXT* a,
+                                                const VkImportMetalSharedEventInfoEXT* b,
+                                                OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void checkEqual_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+    const VkPhysicalDeviceDescriptorBufferPropertiesEXT* a,
+    const VkPhysicalDeviceDescriptorBufferPropertiesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* a,
+    const VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    const VkPhysicalDeviceDescriptorBufferFeaturesEXT* a,
+    const VkPhysicalDeviceDescriptorBufferFeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkDescriptorAddressInfoEXT(const VkDescriptorAddressInfoEXT* a,
+                                           const VkDescriptorAddressInfoEXT* b,
+                                           OnFailCompareFunc onFail);
+
+void checkEqual_VkDescriptorBufferBindingInfoEXT(const VkDescriptorBufferBindingInfoEXT* a,
+                                                 const VkDescriptorBufferBindingInfoEXT* b,
+                                                 OnFailCompareFunc onFail);
+
+void checkEqual_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* a,
+    const VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkDescriptorDataEXT(const VkDescriptorDataEXT* a, const VkDescriptorDataEXT* b,
+                                    OnFailCompareFunc onFail);
+
+void checkEqual_VkDescriptorGetInfoEXT(const VkDescriptorGetInfoEXT* a,
+                                       const VkDescriptorGetInfoEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkBufferCaptureDescriptorDataInfoEXT(const VkBufferCaptureDescriptorDataInfoEXT* a,
+                                                     const VkBufferCaptureDescriptorDataInfoEXT* b,
+                                                     OnFailCompareFunc onFail);
+
+void checkEqual_VkImageCaptureDescriptorDataInfoEXT(const VkImageCaptureDescriptorDataInfoEXT* a,
+                                                    const VkImageCaptureDescriptorDataInfoEXT* b,
+                                                    OnFailCompareFunc onFail);
+
+void checkEqual_VkImageViewCaptureDescriptorDataInfoEXT(
+    const VkImageViewCaptureDescriptorDataInfoEXT* a,
+    const VkImageViewCaptureDescriptorDataInfoEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkSamplerCaptureDescriptorDataInfoEXT(
+    const VkSamplerCaptureDescriptorDataInfoEXT* a, const VkSamplerCaptureDescriptorDataInfoEXT* b,
+    OnFailCompareFunc onFail);
+
+void checkEqual_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    const VkOpaqueCaptureDescriptorDataCreateInfoEXT* a,
+    const VkOpaqueCaptureDescriptorDataCreateInfoEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* a,
+    const VkAccelerationStructureCaptureDescriptorDataInfoEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+void checkEqual_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* a,
+    const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* a,
+    const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkGraphicsPipelineLibraryCreateInfoEXT(
+    const VkGraphicsPipelineLibraryCreateInfoEXT* a,
+    const VkGraphicsPipelineLibraryCreateInfoEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+void checkEqual_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* a,
+    const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* b, OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void checkEqual_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
     const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV* a,
@@ -3341,9 +3768,34 @@ void checkEqual_VkCopyCommandTransformInfoQCOM(const VkCopyCommandTransformInfoQ
 
 #endif
 #ifdef VK_EXT_image_robustness
-void checkEqual_VkPhysicalDeviceImageRobustnessFeaturesEXT(
-    const VkPhysicalDeviceImageRobustnessFeaturesEXT* a,
-    const VkPhysicalDeviceImageRobustnessFeaturesEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceImageRobustnessFeatures,
+                      checkEqual_VkPhysicalDeviceImageRobustnessFeaturesEXT)
+
+#endif
+#ifdef VK_EXT_image_compression_control
+void checkEqual_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* a,
+    const VkPhysicalDeviceImageCompressionControlFeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkImageCompressionControlEXT(const VkImageCompressionControlEXT* a,
+                                             const VkImageCompressionControlEXT* b,
+                                             OnFailCompareFunc onFail);
+
+void checkEqual_VkSubresourceLayout2EXT(const VkSubresourceLayout2EXT* a,
+                                        const VkSubresourceLayout2EXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkImageSubresource2EXT(const VkImageSubresource2EXT* a,
+                                       const VkImageSubresource2EXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkImageCompressionPropertiesEXT(const VkImageCompressionPropertiesEXT* a,
+                                                const VkImageCompressionPropertiesEXT* b,
+                                                OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+void checkEqual_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* a,
+    const VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* b, OnFailCompareFunc onFail);
 
 #endif
 #ifdef VK_EXT_4444_formats
@@ -3352,6 +3804,40 @@ void checkEqual_VkPhysicalDevice4444FormatsFeaturesEXT(
     const VkPhysicalDevice4444FormatsFeaturesEXT* b, OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_EXT_device_fault
+void checkEqual_VkPhysicalDeviceFaultFeaturesEXT(const VkPhysicalDeviceFaultFeaturesEXT* a,
+                                                 const VkPhysicalDeviceFaultFeaturesEXT* b,
+                                                 OnFailCompareFunc onFail);
+
+void checkEqual_VkDeviceFaultCountsEXT(const VkDeviceFaultCountsEXT* a,
+                                       const VkDeviceFaultCountsEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkDeviceFaultAddressInfoEXT(const VkDeviceFaultAddressInfoEXT* a,
+                                            const VkDeviceFaultAddressInfoEXT* b,
+                                            OnFailCompareFunc onFail);
+
+void checkEqual_VkDeviceFaultVendorInfoEXT(const VkDeviceFaultVendorInfoEXT* a,
+                                           const VkDeviceFaultVendorInfoEXT* b,
+                                           OnFailCompareFunc onFail);
+
+void checkEqual_VkDeviceFaultInfoEXT(const VkDeviceFaultInfoEXT* a, const VkDeviceFaultInfoEXT* b,
+                                     OnFailCompareFunc onFail);
+
+void checkEqual_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    const VkDeviceFaultVendorBinaryHeaderVersionOneEXT* a,
+    const VkDeviceFaultVendorBinaryHeaderVersionOneEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+void checkEqual_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* a,
+    const VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* b,
+    OnFailCompareFunc onFail);
+
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
+                      checkEqual_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM)
+
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 void checkEqual_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
     const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* a,
@@ -3367,17 +3853,26 @@ void checkEqual_VkDirectFBSurfaceCreateInfoEXT(const VkDirectFBSurfaceCreateInfo
 
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-void checkEqual_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
-    const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* a,
-    const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* b, OnFailCompareFunc onFail);
+void checkEqual_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
+    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* a,
+    const VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* b, OnFailCompareFunc onFail);
 
-void checkEqual_VkMutableDescriptorTypeListVALVE(const VkMutableDescriptorTypeListVALVE* a,
-                                                 const VkMutableDescriptorTypeListVALVE* b,
-                                                 OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT,
+                      checkEqual_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)
+
+void checkEqual_VkMutableDescriptorTypeListEXT(const VkMutableDescriptorTypeListEXT* a,
+                                               const VkMutableDescriptorTypeListEXT* b,
+                                               OnFailCompareFunc onFail);
+
+DEFINE_ALIAS_FUNCTION(checkEqual_VkMutableDescriptorTypeListEXT,
+                      checkEqual_VkMutableDescriptorTypeListVALVE)
 
-void checkEqual_VkMutableDescriptorTypeCreateInfoVALVE(
-    const VkMutableDescriptorTypeCreateInfoVALVE* a,
-    const VkMutableDescriptorTypeCreateInfoVALVE* b, OnFailCompareFunc onFail);
+void checkEqual_VkMutableDescriptorTypeCreateInfoEXT(const VkMutableDescriptorTypeCreateInfoEXT* a,
+                                                     const VkMutableDescriptorTypeCreateInfoEXT* b,
+                                                     OnFailCompareFunc onFail);
+
+DEFINE_ALIAS_FUNCTION(checkEqual_VkMutableDescriptorTypeCreateInfoEXT,
+                      checkEqual_VkMutableDescriptorTypeCreateInfoVALVE)
 
 #endif
 #ifdef VK_EXT_vertex_input_dynamic_state
@@ -3400,6 +3895,26 @@ void checkEqual_VkPhysicalDeviceDrmPropertiesEXT(const VkPhysicalDeviceDrmProper
                                                  OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_EXT_device_address_binding_report
+void checkEqual_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* a,
+    const VkPhysicalDeviceAddressBindingReportFeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkDeviceAddressBindingCallbackDataEXT(
+    const VkDeviceAddressBindingCallbackDataEXT* a, const VkDeviceAddressBindingCallbackDataEXT* b,
+    OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_depth_clip_control
+void checkEqual_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    const VkPhysicalDeviceDepthClipControlFeaturesEXT* a,
+    const VkPhysicalDeviceDepthClipControlFeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    const VkPipelineViewportDepthClipControlCreateInfoEXT* a,
+    const VkPipelineViewportDepthClipControlCreateInfoEXT* b, OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 void checkEqual_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
     const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT* a,
@@ -3502,6 +4017,33 @@ void checkEqual_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
     const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* b, OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_EXT_pipeline_properties
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPipelineInfoKHR, checkEqual_VkPipelineInfoEXT)
+
+void checkEqual_VkPipelinePropertiesIdentifierEXT(const VkPipelinePropertiesIdentifierEXT* a,
+                                                  const VkPipelinePropertiesIdentifierEXT* b,
+                                                  OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    const VkPhysicalDevicePipelinePropertiesFeaturesEXT* a,
+    const VkPhysicalDevicePipelinePropertiesFeaturesEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+void checkEqual_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* a,
+    const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* b,
+    OnFailCompareFunc onFail);
+
+void checkEqual_VkSubpassResolvePerformanceQueryEXT(const VkSubpassResolvePerformanceQueryEXT* a,
+                                                    const VkSubpassResolvePerformanceQueryEXT* b,
+                                                    OnFailCompareFunc onFail);
+
+void checkEqual_VkMultisampledRenderToSingleSampledInfoEXT(
+    const VkMultisampledRenderToSingleSampledInfoEXT* a,
+    const VkMultisampledRenderToSingleSampledInfoEXT* b, OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void checkEqual_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
     const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT* a,
@@ -3524,6 +4066,12 @@ void checkEqual_VkPipelineColorWriteCreateInfoEXT(const VkPipelineColorWriteCrea
                                                   OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_EXT_primitives_generated_query
+void checkEqual_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* a,
+    const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* b, OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_GOOGLE_gfxstream
 void checkEqual_VkImportColorBufferGOOGLE(const VkImportColorBufferGOOGLE* a,
                                           const VkImportColorBufferGOOGLE* b,
@@ -3537,13 +4085,21 @@ void checkEqual_VkCreateBlobGOOGLE(const VkCreateBlobGOOGLE* a, const VkCreateBl
 
 #endif
 #ifdef VK_EXT_global_priority_query
-void checkEqual_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
-    const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* a,
-    const VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR,
+                      checkEqual_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT)
 
-void checkEqual_VkQueueFamilyGlobalPriorityPropertiesEXT(
-    const VkQueueFamilyGlobalPriorityPropertiesEXT* a,
-    const VkQueueFamilyGlobalPriorityPropertiesEXT* b, OnFailCompareFunc onFail);
+DEFINE_ALIAS_FUNCTION(checkEqual_VkQueueFamilyGlobalPriorityPropertiesKHR,
+                      checkEqual_VkQueueFamilyGlobalPriorityPropertiesEXT)
+
+#endif
+#ifdef VK_EXT_image_view_min_lod
+void checkEqual_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
+    const VkPhysicalDeviceImageViewMinLodFeaturesEXT* a,
+    const VkPhysicalDeviceImageViewMinLodFeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkImageViewMinLodCreateInfoEXT(const VkImageViewMinLodCreateInfoEXT* a,
+                                               const VkImageViewMinLodCreateInfoEXT* b,
+                                               OnFailCompareFunc onFail);
 
 #endif
 #ifdef VK_EXT_multi_draw
@@ -3563,8 +4119,97 @@ void checkEqual_VkMultiDrawIndexedInfoEXT(const VkMultiDrawIndexedInfoEXT* a,
                                           OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+void checkEqual_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* a,
+    const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_shader_tile_image
+void checkEqual_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    const VkPhysicalDeviceShaderTileImageFeaturesEXT* a,
+    const VkPhysicalDeviceShaderTileImageFeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    const VkPhysicalDeviceShaderTileImagePropertiesEXT* a,
+    const VkPhysicalDeviceShaderTileImagePropertiesEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_opacity_micromap
+void checkEqual_VkMicromapUsageEXT(const VkMicromapUsageEXT* a, const VkMicromapUsageEXT* b,
+                                   OnFailCompareFunc onFail);
+
+void checkEqual_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* a,
+                                         const VkDeviceOrHostAddressKHR* b,
+                                         OnFailCompareFunc onFail);
+
+void checkEqual_VkMicromapBuildInfoEXT(const VkMicromapBuildInfoEXT* a,
+                                       const VkMicromapBuildInfoEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkMicromapCreateInfoEXT(const VkMicromapCreateInfoEXT* a,
+                                        const VkMicromapCreateInfoEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    const VkPhysicalDeviceOpacityMicromapFeaturesEXT* a,
+    const VkPhysicalDeviceOpacityMicromapFeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    const VkPhysicalDeviceOpacityMicromapPropertiesEXT* a,
+    const VkPhysicalDeviceOpacityMicromapPropertiesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkMicromapVersionInfoEXT(const VkMicromapVersionInfoEXT* a,
+                                         const VkMicromapVersionInfoEXT* b,
+                                         OnFailCompareFunc onFail);
+
+void checkEqual_VkCopyMicromapToMemoryInfoEXT(const VkCopyMicromapToMemoryInfoEXT* a,
+                                              const VkCopyMicromapToMemoryInfoEXT* b,
+                                              OnFailCompareFunc onFail);
+
+void checkEqual_VkCopyMemoryToMicromapInfoEXT(const VkCopyMemoryToMicromapInfoEXT* a,
+                                              const VkCopyMemoryToMicromapInfoEXT* b,
+                                              OnFailCompareFunc onFail);
+
+void checkEqual_VkCopyMicromapInfoEXT(const VkCopyMicromapInfoEXT* a,
+                                      const VkCopyMicromapInfoEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkMicromapBuildSizesInfoEXT(const VkMicromapBuildSizesInfoEXT* a,
+                                            const VkMicromapBuildSizesInfoEXT* b,
+                                            OnFailCompareFunc onFail);
+
+void checkEqual_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    const VkAccelerationStructureTrianglesOpacityMicromapEXT* a,
+    const VkAccelerationStructureTrianglesOpacityMicromapEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkMicromapTriangleEXT(const VkMicromapTriangleEXT* a,
+                                      const VkMicromapTriangleEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_NV_displacement_micromap
+void checkEqual_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* a,
+    const VkPhysicalDeviceDisplacementMicromapFeaturesNV* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* a,
+    const VkPhysicalDeviceDisplacementMicromapPropertiesNV* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    const VkAccelerationStructureTrianglesDisplacementMicromapNV* a,
+    const VkAccelerationStructureTrianglesDisplacementMicromapNV* b, OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void checkEqual_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* a,
+    const VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* a,
+    const VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* b, OnFailCompareFunc onFail);
+
+#endif
 #ifdef VK_EXT_border_color_swizzle
 void checkEqual_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
     const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT* a,
@@ -3581,11 +4226,323 @@ void checkEqual_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
     const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* b, OnFailCompareFunc onFail);
 
 #endif
-#ifdef VK_KHR_acceleration_structure
-void checkEqual_VkDeviceOrHostAddressKHR(const VkDeviceOrHostAddressKHR* a,
-                                         const VkDeviceOrHostAddressKHR* b,
-                                         OnFailCompareFunc onFail);
+#ifdef VK_ARM_shader_core_properties
+void checkEqual_VkPhysicalDeviceShaderCorePropertiesARM(
+    const VkPhysicalDeviceShaderCorePropertiesARM* a,
+    const VkPhysicalDeviceShaderCorePropertiesARM* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+void checkEqual_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* a,
+    const VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkImageViewSlicedCreateInfoEXT(const VkImageViewSlicedCreateInfoEXT* a,
+                                               const VkImageViewSlicedCreateInfoEXT* b,
+                                               OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void checkEqual_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* a,
+    const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkDescriptorSetBindingReferenceVALVE(const VkDescriptorSetBindingReferenceVALVE* a,
+                                                     const VkDescriptorSetBindingReferenceVALVE* b,
+                                                     OnFailCompareFunc onFail);
+
+void checkEqual_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    const VkDescriptorSetLayoutHostMappingInfoVALVE* a,
+    const VkDescriptorSetLayoutHostMappingInfoVALVE* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+void checkEqual_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* a,
+    const VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+void checkEqual_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* a,
+    const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+void checkEqual_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* a,
+    const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* a,
+    const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* a,
+    const VkSubpassFragmentDensityMapOffsetEndInfoQCOM* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void checkEqual_VkCopyMemoryIndirectCommandNV(const VkCopyMemoryIndirectCommandNV* a,
+                                              const VkCopyMemoryIndirectCommandNV* b,
+                                              OnFailCompareFunc onFail);
+
+void checkEqual_VkCopyMemoryToImageIndirectCommandNV(const VkCopyMemoryToImageIndirectCommandNV* a,
+                                                     const VkCopyMemoryToImageIndirectCommandNV* b,
+                                                     OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* a,
+    const VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* a,
+    const VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_NV_memory_decompression
+void checkEqual_VkDecompressMemoryRegionNV(const VkDecompressMemoryRegionNV* a,
+                                           const VkDecompressMemoryRegionNV* b,
+                                           OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    const VkPhysicalDeviceMemoryDecompressionFeaturesNV* a,
+    const VkPhysicalDeviceMemoryDecompressionFeaturesNV* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* a,
+    const VkPhysicalDeviceMemoryDecompressionPropertiesNV* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_NV_linear_color_attachment
+void checkEqual_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* a,
+    const VkPhysicalDeviceLinearColorAttachmentFeaturesNV* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+void checkEqual_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* a,
+    const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_QCOM_image_processing
+void checkEqual_VkImageViewSampleWeightCreateInfoQCOM(
+    const VkImageViewSampleWeightCreateInfoQCOM* a, const VkImageViewSampleWeightCreateInfoQCOM* b,
+    OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    const VkPhysicalDeviceImageProcessingFeaturesQCOM* a,
+    const VkPhysicalDeviceImageProcessingFeaturesQCOM* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    const VkPhysicalDeviceImageProcessingPropertiesQCOM* a,
+    const VkPhysicalDeviceImageProcessingPropertiesQCOM* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void checkEqual_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* a,
+    const VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* a,
+    const VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkColorBlendEquationEXT(const VkColorBlendEquationEXT* a,
+                                        const VkColorBlendEquationEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkColorBlendAdvancedEXT(const VkColorBlendAdvancedEXT* a,
+                                        const VkColorBlendAdvancedEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+void checkEqual_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* a,
+    const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkRenderPassCreationControlEXT(const VkRenderPassCreationControlEXT* a,
+                                               const VkRenderPassCreationControlEXT* b,
+                                               OnFailCompareFunc onFail);
+
+void checkEqual_VkRenderPassCreationFeedbackInfoEXT(const VkRenderPassCreationFeedbackInfoEXT* a,
+                                                    const VkRenderPassCreationFeedbackInfoEXT* b,
+                                                    OnFailCompareFunc onFail);
+
+void checkEqual_VkRenderPassCreationFeedbackCreateInfoEXT(
+    const VkRenderPassCreationFeedbackCreateInfoEXT* a,
+    const VkRenderPassCreationFeedbackCreateInfoEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkRenderPassSubpassFeedbackInfoEXT(const VkRenderPassSubpassFeedbackInfoEXT* a,
+                                                   const VkRenderPassSubpassFeedbackInfoEXT* b,
+                                                   OnFailCompareFunc onFail);
+
+void checkEqual_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    const VkRenderPassSubpassFeedbackCreateInfoEXT* a,
+    const VkRenderPassSubpassFeedbackCreateInfoEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+void checkEqual_VkDirectDriverLoadingInfoLUNARG(const VkDirectDriverLoadingInfoLUNARG* a,
+                                                const VkDirectDriverLoadingInfoLUNARG* b,
+                                                OnFailCompareFunc onFail);
+
+void checkEqual_VkDirectDriverLoadingListLUNARG(const VkDirectDriverLoadingListLUNARG* a,
+                                                const VkDirectDriverLoadingListLUNARG* b,
+                                                OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void checkEqual_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* a,
+    const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* a,
+    const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* a,
+    const VkPipelineShaderStageModuleIdentifierCreateInfoEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkShaderModuleIdentifierEXT(const VkShaderModuleIdentifierEXT* a,
+                                            const VkShaderModuleIdentifierEXT* b,
+                                            OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+void checkEqual_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    const VkPhysicalDeviceOpticalFlowFeaturesNV* a, const VkPhysicalDeviceOpticalFlowFeaturesNV* b,
+    OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    const VkPhysicalDeviceOpticalFlowPropertiesNV* a,
+    const VkPhysicalDeviceOpticalFlowPropertiesNV* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkOpticalFlowImageFormatInfoNV(const VkOpticalFlowImageFormatInfoNV* a,
+                                               const VkOpticalFlowImageFormatInfoNV* b,
+                                               OnFailCompareFunc onFail);
+
+void checkEqual_VkOpticalFlowImageFormatPropertiesNV(const VkOpticalFlowImageFormatPropertiesNV* a,
+                                                     const VkOpticalFlowImageFormatPropertiesNV* b,
+                                                     OnFailCompareFunc onFail);
+
+void checkEqual_VkOpticalFlowSessionCreateInfoNV(const VkOpticalFlowSessionCreateInfoNV* a,
+                                                 const VkOpticalFlowSessionCreateInfoNV* b,
+                                                 OnFailCompareFunc onFail);
+
+void checkEqual_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    const VkOpticalFlowSessionCreatePrivateDataInfoNV* a,
+    const VkOpticalFlowSessionCreatePrivateDataInfoNV* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkOpticalFlowExecuteInfoNV(const VkOpticalFlowExecuteInfoNV* a,
+                                           const VkOpticalFlowExecuteInfoNV* b,
+                                           OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_legacy_dithering
+void checkEqual_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    const VkPhysicalDeviceLegacyDitheringFeaturesEXT* a,
+    const VkPhysicalDeviceLegacyDitheringFeaturesEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+void checkEqual_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* a,
+    const VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_shader_object
+void checkEqual_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    const VkPhysicalDeviceShaderObjectFeaturesEXT* a,
+    const VkPhysicalDeviceShaderObjectFeaturesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    const VkPhysicalDeviceShaderObjectPropertiesEXT* a,
+    const VkPhysicalDeviceShaderObjectPropertiesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkShaderCreateInfoEXT(const VkShaderCreateInfoEXT* a,
+                                      const VkShaderCreateInfoEXT* b, OnFailCompareFunc onFail);
+
+DEFINE_ALIAS_FUNCTION(checkEqual_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      checkEqual_VkShaderRequiredSubgroupSizeCreateInfoEXT)
 
+#endif
+#ifdef VK_QCOM_tile_properties
+void checkEqual_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    const VkPhysicalDeviceTilePropertiesFeaturesQCOM* a,
+    const VkPhysicalDeviceTilePropertiesFeaturesQCOM* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkTilePropertiesQCOM(const VkTilePropertiesQCOM* a, const VkTilePropertiesQCOM* b,
+                                     OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_SEC_amigo_profiling
+void checkEqual_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    const VkPhysicalDeviceAmigoProfilingFeaturesSEC* a,
+    const VkPhysicalDeviceAmigoProfilingFeaturesSEC* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkAmigoProfilingSubmitInfoSEC(const VkAmigoProfilingSubmitInfoSEC* a,
+                                              const VkAmigoProfilingSubmitInfoSEC* b,
+                                              OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+void checkEqual_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* a,
+    const VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+void checkEqual_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* a,
+    const VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* a,
+    const VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+void checkEqual_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* a,
+    const VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* a,
+    const VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+void checkEqual_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* a,
+    const VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+void checkEqual_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* a,
+    const VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* a,
+    const VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* b, OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+void checkEqual_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* a,
+    const VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* b,
+    OnFailCompareFunc onFail);
+
+#endif
+#ifdef VK_KHR_acceleration_structure
 void checkEqual_VkAccelerationStructureBuildRangeInfoKHR(
     const VkAccelerationStructureBuildRangeInfoKHR* a,
     const VkAccelerationStructureBuildRangeInfoKHR* b, OnFailCompareFunc onFail);
@@ -3691,6 +4648,20 @@ void checkEqual_VkPhysicalDeviceRayQueryFeaturesKHR(const VkPhysicalDeviceRayQue
                                                     OnFailCompareFunc onFail);
 
 #endif
+#ifdef VK_EXT_mesh_shader
+void checkEqual_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    const VkPhysicalDeviceMeshShaderFeaturesEXT* a, const VkPhysicalDeviceMeshShaderFeaturesEXT* b,
+    OnFailCompareFunc onFail);
+
+void checkEqual_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    const VkPhysicalDeviceMeshShaderPropertiesEXT* a,
+    const VkPhysicalDeviceMeshShaderPropertiesEXT* b, OnFailCompareFunc onFail);
+
+void checkEqual_VkDrawMeshTasksIndirectCommandEXT(const VkDrawMeshTasksIndirectCommandEXT* a,
+                                                  const VkDrawMeshTasksIndirectCommandEXT* b,
+                                                  OnFailCompareFunc onFail);
+
+#endif
 
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_transform.cpp b/stream-servers/vulkan/cereal/common/goldfish_vk_transform.cpp
index 894a2bab..7500dd45 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_transform.cpp
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_transform.cpp
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_transform
 //
-// (impl) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml cereal
-// -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (impl) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -4811,6 +4811,1332 @@ void transform_fromhost_VkDeviceMemoryOpaqueCaptureAddressInfo(
 }
 
 #endif
+#ifdef VK_VERSION_1_3
+void transform_tohost_VkPhysicalDeviceVulkan13Features(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceVulkan13Features* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceVulkan13Features(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceVulkan13Features* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceVulkan13Properties(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceVulkan13Properties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceVulkan13Properties(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceVulkan13Properties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPipelineCreationFeedback(VkDecoderGlobalState* resourceTracker,
+                                                 VkPipelineCreationFeedback* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkPipelineCreationFeedback(VkDecoderGlobalState* resourceTracker,
+                                                   VkPipelineCreationFeedback* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_tohost_VkPipelineCreationFeedbackCreateInfo(
+    VkDecoderGlobalState* resourceTracker, VkPipelineCreationFeedbackCreateInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pPipelineCreationFeedback) {
+        transform_tohost_VkPipelineCreationFeedback(
+            resourceTracker, (VkPipelineCreationFeedback*)(toTransform->pPipelineCreationFeedback));
+    }
+    if (toTransform) {
+        if (toTransform->pPipelineStageCreationFeedbacks) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->pipelineStageCreationFeedbackCount;
+                 ++i) {
+                transform_tohost_VkPipelineCreationFeedback(
+                    resourceTracker,
+                    (VkPipelineCreationFeedback*)(toTransform->pPipelineStageCreationFeedbacks +
+                                                  i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkPipelineCreationFeedbackCreateInfo(
+    VkDecoderGlobalState* resourceTracker, VkPipelineCreationFeedbackCreateInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pPipelineCreationFeedback) {
+        transform_fromhost_VkPipelineCreationFeedback(
+            resourceTracker, (VkPipelineCreationFeedback*)(toTransform->pPipelineCreationFeedback));
+    }
+    if (toTransform) {
+        if (toTransform->pPipelineStageCreationFeedbacks) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->pipelineStageCreationFeedbackCount;
+                 ++i) {
+                transform_fromhost_VkPipelineCreationFeedback(
+                    resourceTracker,
+                    (VkPipelineCreationFeedback*)(toTransform->pPipelineStageCreationFeedbacks +
+                                                  i));
+            }
+        }
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderTerminateInvocationFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderTerminateInvocationFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceToolProperties(VkDecoderGlobalState* resourceTracker,
+                                                     VkPhysicalDeviceToolProperties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceToolProperties(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceToolProperties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDevicePrivateDataFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDevicePrivateDataFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDevicePrivateDataFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDevicePrivateDataFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDevicePrivateDataCreateInfo(VkDecoderGlobalState* resourceTracker,
+                                                    VkDevicePrivateDataCreateInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkDevicePrivateDataCreateInfo(VkDecoderGlobalState* resourceTracker,
+                                                      VkDevicePrivateDataCreateInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPrivateDataSlotCreateInfo(VkDecoderGlobalState* resourceTracker,
+                                                  VkPrivateDataSlotCreateInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPrivateDataSlotCreateInfo(VkDecoderGlobalState* resourceTracker,
+                                                    VkPrivateDataSlotCreateInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineCreationCacheControlFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineCreationCacheControlFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkMemoryBarrier2(VkDecoderGlobalState* resourceTracker,
+                                       VkMemoryBarrier2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkMemoryBarrier2(VkDecoderGlobalState* resourceTracker,
+                                         VkMemoryBarrier2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkBufferMemoryBarrier2(VkDecoderGlobalState* resourceTracker,
+                                             VkBufferMemoryBarrier2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkBufferMemoryBarrier2(VkDecoderGlobalState* resourceTracker,
+                                               VkBufferMemoryBarrier2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkImageMemoryBarrier2(VkDecoderGlobalState* resourceTracker,
+                                            VkImageMemoryBarrier2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkImageSubresourceRange(
+        resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
+}
+
+void transform_fromhost_VkImageMemoryBarrier2(VkDecoderGlobalState* resourceTracker,
+                                              VkImageMemoryBarrier2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkImageSubresourceRange(
+        resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
+}
+
+void transform_tohost_VkDependencyInfo(VkDecoderGlobalState* resourceTracker,
+                                       VkDependencyInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pMemoryBarriers) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->memoryBarrierCount; ++i) {
+                transform_tohost_VkMemoryBarrier2(
+                    resourceTracker, (VkMemoryBarrier2*)(toTransform->pMemoryBarriers + i));
+            }
+        }
+    }
+    if (toTransform) {
+        if (toTransform->pBufferMemoryBarriers) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->bufferMemoryBarrierCount; ++i) {
+                transform_tohost_VkBufferMemoryBarrier2(
+                    resourceTracker,
+                    (VkBufferMemoryBarrier2*)(toTransform->pBufferMemoryBarriers + i));
+            }
+        }
+    }
+    if (toTransform) {
+        if (toTransform->pImageMemoryBarriers) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->imageMemoryBarrierCount; ++i) {
+                transform_tohost_VkImageMemoryBarrier2(
+                    resourceTracker,
+                    (VkImageMemoryBarrier2*)(toTransform->pImageMemoryBarriers + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkDependencyInfo(VkDecoderGlobalState* resourceTracker,
+                                         VkDependencyInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pMemoryBarriers) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->memoryBarrierCount; ++i) {
+                transform_fromhost_VkMemoryBarrier2(
+                    resourceTracker, (VkMemoryBarrier2*)(toTransform->pMemoryBarriers + i));
+            }
+        }
+    }
+    if (toTransform) {
+        if (toTransform->pBufferMemoryBarriers) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->bufferMemoryBarrierCount; ++i) {
+                transform_fromhost_VkBufferMemoryBarrier2(
+                    resourceTracker,
+                    (VkBufferMemoryBarrier2*)(toTransform->pBufferMemoryBarriers + i));
+            }
+        }
+    }
+    if (toTransform) {
+        if (toTransform->pImageMemoryBarriers) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->imageMemoryBarrierCount; ++i) {
+                transform_fromhost_VkImageMemoryBarrier2(
+                    resourceTracker,
+                    (VkImageMemoryBarrier2*)(toTransform->pImageMemoryBarriers + i));
+            }
+        }
+    }
+}
+
+void transform_tohost_VkSemaphoreSubmitInfo(VkDecoderGlobalState* resourceTracker,
+                                            VkSemaphoreSubmitInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkSemaphoreSubmitInfo(VkDecoderGlobalState* resourceTracker,
+                                              VkSemaphoreSubmitInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkCommandBufferSubmitInfo(VkDecoderGlobalState* resourceTracker,
+                                                VkCommandBufferSubmitInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkCommandBufferSubmitInfo(VkDecoderGlobalState* resourceTracker,
+                                                  VkCommandBufferSubmitInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkSubmitInfo2(VkDecoderGlobalState* resourceTracker,
+                                    VkSubmitInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pWaitSemaphoreInfos) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->waitSemaphoreInfoCount; ++i) {
+                transform_tohost_VkSemaphoreSubmitInfo(
+                    resourceTracker,
+                    (VkSemaphoreSubmitInfo*)(toTransform->pWaitSemaphoreInfos + i));
+            }
+        }
+    }
+    if (toTransform) {
+        if (toTransform->pCommandBufferInfos) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->commandBufferInfoCount; ++i) {
+                transform_tohost_VkCommandBufferSubmitInfo(
+                    resourceTracker,
+                    (VkCommandBufferSubmitInfo*)(toTransform->pCommandBufferInfos + i));
+            }
+        }
+    }
+    if (toTransform) {
+        if (toTransform->pSignalSemaphoreInfos) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->signalSemaphoreInfoCount; ++i) {
+                transform_tohost_VkSemaphoreSubmitInfo(
+                    resourceTracker,
+                    (VkSemaphoreSubmitInfo*)(toTransform->pSignalSemaphoreInfos + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkSubmitInfo2(VkDecoderGlobalState* resourceTracker,
+                                      VkSubmitInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pWaitSemaphoreInfos) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->waitSemaphoreInfoCount; ++i) {
+                transform_fromhost_VkSemaphoreSubmitInfo(
+                    resourceTracker,
+                    (VkSemaphoreSubmitInfo*)(toTransform->pWaitSemaphoreInfos + i));
+            }
+        }
+    }
+    if (toTransform) {
+        if (toTransform->pCommandBufferInfos) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->commandBufferInfoCount; ++i) {
+                transform_fromhost_VkCommandBufferSubmitInfo(
+                    resourceTracker,
+                    (VkCommandBufferSubmitInfo*)(toTransform->pCommandBufferInfos + i));
+            }
+        }
+    }
+    if (toTransform) {
+        if (toTransform->pSignalSemaphoreInfos) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->signalSemaphoreInfoCount; ++i) {
+                transform_fromhost_VkSemaphoreSubmitInfo(
+                    resourceTracker,
+                    (VkSemaphoreSubmitInfo*)(toTransform->pSignalSemaphoreInfos + i));
+            }
+        }
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceSynchronization2Features(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceSynchronization2Features* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceSynchronization2Features(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceSynchronization2Features* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceImageRobustnessFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceImageRobustnessFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceImageRobustnessFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceImageRobustnessFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkBufferCopy2(VkDecoderGlobalState* resourceTracker,
+                                    VkBufferCopy2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkBufferCopy2(VkDecoderGlobalState* resourceTracker,
+                                      VkBufferCopy2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkCopyBufferInfo2(VkDecoderGlobalState* resourceTracker,
+                                        VkCopyBufferInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_tohost_VkBufferCopy2(resourceTracker,
+                                               (VkBufferCopy2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkCopyBufferInfo2(VkDecoderGlobalState* resourceTracker,
+                                          VkCopyBufferInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_fromhost_VkBufferCopy2(resourceTracker,
+                                                 (VkBufferCopy2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_tohost_VkImageCopy2(VkDecoderGlobalState* resourceTracker,
+                                   VkImageCopy2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+    transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
+    transform_tohost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+    transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
+    transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
+}
+
+void transform_fromhost_VkImageCopy2(VkDecoderGlobalState* resourceTracker,
+                                     VkImageCopy2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+    transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
+    transform_fromhost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+    transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
+    transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
+}
+
+void transform_tohost_VkCopyImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                       VkCopyImageInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_tohost_VkImageCopy2(resourceTracker,
+                                              (VkImageCopy2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkCopyImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                         VkCopyImageInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_fromhost_VkImageCopy2(resourceTracker,
+                                                (VkImageCopy2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_tohost_VkBufferImageCopy2(VkDecoderGlobalState* resourceTracker,
+                                         VkBufferImageCopy2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+    transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
+    transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
+}
+
+void transform_fromhost_VkBufferImageCopy2(VkDecoderGlobalState* resourceTracker,
+                                           VkBufferImageCopy2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+    transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
+    transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
+}
+
+void transform_tohost_VkCopyBufferToImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                               VkCopyBufferToImageInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_tohost_VkBufferImageCopy2(
+                    resourceTracker, (VkBufferImageCopy2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkCopyBufferToImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                                 VkCopyBufferToImageInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_fromhost_VkBufferImageCopy2(
+                    resourceTracker, (VkBufferImageCopy2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_tohost_VkCopyImageToBufferInfo2(VkDecoderGlobalState* resourceTracker,
+                                               VkCopyImageToBufferInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_tohost_VkBufferImageCopy2(
+                    resourceTracker, (VkBufferImageCopy2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkCopyImageToBufferInfo2(VkDecoderGlobalState* resourceTracker,
+                                                 VkCopyImageToBufferInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_fromhost_VkBufferImageCopy2(
+                    resourceTracker, (VkBufferImageCopy2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_tohost_VkImageBlit2(VkDecoderGlobalState* resourceTracker,
+                                   VkImageBlit2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->srcOffsets + i));
+    }
+    transform_tohost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->dstOffsets + i));
+    }
+}
+
+void transform_fromhost_VkImageBlit2(VkDecoderGlobalState* resourceTracker,
+                                     VkImageBlit2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->srcOffsets + i));
+    }
+    transform_fromhost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
+        transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->dstOffsets + i));
+    }
+}
+
+void transform_tohost_VkBlitImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                       VkBlitImageInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_tohost_VkImageBlit2(resourceTracker,
+                                              (VkImageBlit2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkBlitImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                         VkBlitImageInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_fromhost_VkImageBlit2(resourceTracker,
+                                                (VkImageBlit2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_tohost_VkImageResolve2(VkDecoderGlobalState* resourceTracker,
+                                      VkImageResolve2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+    transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
+    transform_tohost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+    transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
+    transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
+}
+
+void transform_fromhost_VkImageResolve2(VkDecoderGlobalState* resourceTracker,
+                                        VkImageResolve2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
+    transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
+    transform_fromhost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
+    transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
+    transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
+}
+
+void transform_tohost_VkResolveImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                          VkResolveImageInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_tohost_VkImageResolve2(resourceTracker,
+                                                 (VkImageResolve2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkResolveImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                            VkResolveImageInfo2* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_fromhost_VkImageResolve2(resourceTracker,
+                                                   (VkImageResolve2*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceSubgroupSizeControlFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceSubgroupSizeControlFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceSubgroupSizeControlProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceSubgroupSizeControlProperties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceSubgroupSizeControlProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceSubgroupSizeControlProperties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    VkDecoderGlobalState* resourceTracker,
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    VkDecoderGlobalState* resourceTracker,
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceInlineUniformBlockFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceInlineUniformBlockFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceInlineUniformBlockFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceInlineUniformBlockFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceInlineUniformBlockProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceInlineUniformBlockProperties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceInlineUniformBlockProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceInlineUniformBlockProperties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkWriteDescriptorSetInlineUniformBlock(
+    VkDecoderGlobalState* resourceTracker, VkWriteDescriptorSetInlineUniformBlock* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkWriteDescriptorSetInlineUniformBlock(
+    VkDecoderGlobalState* resourceTracker, VkWriteDescriptorSetInlineUniformBlock* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    VkDecoderGlobalState* resourceTracker,
+    VkDescriptorPoolInlineUniformBlockCreateInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    VkDecoderGlobalState* resourceTracker,
+    VkDescriptorPoolInlineUniformBlockCreateInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkRenderingAttachmentInfo(VkDecoderGlobalState* resourceTracker,
+                                                VkRenderingAttachmentInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkClearValue(resourceTracker, (VkClearValue*)(&toTransform->clearValue));
+}
+
+void transform_fromhost_VkRenderingAttachmentInfo(VkDecoderGlobalState* resourceTracker,
+                                                  VkRenderingAttachmentInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkClearValue(resourceTracker, (VkClearValue*)(&toTransform->clearValue));
+}
+
+void transform_tohost_VkRenderingInfo(VkDecoderGlobalState* resourceTracker,
+                                      VkRenderingInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->renderArea));
+    if (toTransform) {
+        if (toTransform->pColorAttachments) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
+                transform_tohost_VkRenderingAttachmentInfo(
+                    resourceTracker,
+                    (VkRenderingAttachmentInfo*)(toTransform->pColorAttachments + i));
+            }
+        }
+    }
+    if (toTransform->pDepthAttachment) {
+        transform_tohost_VkRenderingAttachmentInfo(
+            resourceTracker, (VkRenderingAttachmentInfo*)(toTransform->pDepthAttachment));
+    }
+    if (toTransform->pStencilAttachment) {
+        transform_tohost_VkRenderingAttachmentInfo(
+            resourceTracker, (VkRenderingAttachmentInfo*)(toTransform->pStencilAttachment));
+    }
+}
+
+void transform_fromhost_VkRenderingInfo(VkDecoderGlobalState* resourceTracker,
+                                        VkRenderingInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->renderArea));
+    if (toTransform) {
+        if (toTransform->pColorAttachments) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
+                transform_fromhost_VkRenderingAttachmentInfo(
+                    resourceTracker,
+                    (VkRenderingAttachmentInfo*)(toTransform->pColorAttachments + i));
+            }
+        }
+    }
+    if (toTransform->pDepthAttachment) {
+        transform_fromhost_VkRenderingAttachmentInfo(
+            resourceTracker, (VkRenderingAttachmentInfo*)(toTransform->pDepthAttachment));
+    }
+    if (toTransform->pStencilAttachment) {
+        transform_fromhost_VkRenderingAttachmentInfo(
+            resourceTracker, (VkRenderingAttachmentInfo*)(toTransform->pStencilAttachment));
+    }
+}
+
+void transform_tohost_VkPipelineRenderingCreateInfo(VkDecoderGlobalState* resourceTracker,
+                                                    VkPipelineRenderingCreateInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPipelineRenderingCreateInfo(VkDecoderGlobalState* resourceTracker,
+                                                      VkPipelineRenderingCreateInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceDynamicRenderingFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceDynamicRenderingFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceDynamicRenderingFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceDynamicRenderingFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkCommandBufferInheritanceRenderingInfo(
+    VkDecoderGlobalState* resourceTracker, VkCommandBufferInheritanceRenderingInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkCommandBufferInheritanceRenderingInfo(
+    VkDecoderGlobalState* resourceTracker, VkCommandBufferInheritanceRenderingInfo* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderIntegerDotProductFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderIntegerDotProductFeatures* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderIntegerDotProductProperties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderIntegerDotProductProperties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceTexelBufferAlignmentProperties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceTexelBufferAlignmentProperties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkFormatProperties3(VkDecoderGlobalState* resourceTracker,
+                                          VkFormatProperties3* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkFormatProperties3(VkDecoderGlobalState* resourceTracker,
+                                            VkFormatProperties3* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceMaintenance4Features(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4Features* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceMaintenance4Features(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4Features* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceMaintenance4Properties(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4Properties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceMaintenance4Properties(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4Properties* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDeviceBufferMemoryRequirements(
+    VkDecoderGlobalState* resourceTracker, VkDeviceBufferMemoryRequirements* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pCreateInfo) {
+        transform_tohost_VkBufferCreateInfo(resourceTracker,
+                                            (VkBufferCreateInfo*)(toTransform->pCreateInfo));
+    }
+}
+
+void transform_fromhost_VkDeviceBufferMemoryRequirements(
+    VkDecoderGlobalState* resourceTracker, VkDeviceBufferMemoryRequirements* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pCreateInfo) {
+        transform_fromhost_VkBufferCreateInfo(resourceTracker,
+                                              (VkBufferCreateInfo*)(toTransform->pCreateInfo));
+    }
+}
+
+void transform_tohost_VkDeviceImageMemoryRequirements(
+    VkDecoderGlobalState* resourceTracker, VkDeviceImageMemoryRequirements* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pCreateInfo) {
+        resourceTracker->transformImpl_VkImageCreateInfo_tohost(toTransform->pCreateInfo, 1);
+        transform_tohost_VkImageCreateInfo(resourceTracker,
+                                           (VkImageCreateInfo*)(toTransform->pCreateInfo));
+    }
+}
+
+void transform_fromhost_VkDeviceImageMemoryRequirements(
+    VkDecoderGlobalState* resourceTracker, VkDeviceImageMemoryRequirements* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pCreateInfo) {
+        resourceTracker->transformImpl_VkImageCreateInfo_fromhost(toTransform->pCreateInfo, 1);
+        transform_fromhost_VkImageCreateInfo(resourceTracker,
+                                             (VkImageCreateInfo*)(toTransform->pCreateInfo));
+    }
+}
+
+#endif
 #ifdef VK_KHR_surface
 void transform_tohost_VkSurfaceCapabilitiesKHR(VkDecoderGlobalState* resourceTracker,
                                                VkSurfaceCapabilitiesKHR* toTransform) {
@@ -5248,8 +6574,9 @@ void transform_fromhost_VkWin32SurfaceCreateInfoKHR(VkDecoderGlobalState* resour
 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
 #endif
 #ifdef VK_KHR_video_queue
-void transform_tohost_VkVideoQueueFamilyProperties2KHR(
-    VkDecoderGlobalState* resourceTracker, VkVideoQueueFamilyProperties2KHR* toTransform) {
+void transform_tohost_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkQueueFamilyQueryResultStatusPropertiesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -5257,8 +6584,9 @@ void transform_tohost_VkVideoQueueFamilyProperties2KHR(
     }
 }
 
-void transform_fromhost_VkVideoQueueFamilyProperties2KHR(
-    VkDecoderGlobalState* resourceTracker, VkVideoQueueFamilyProperties2KHR* toTransform) {
+void transform_fromhost_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkQueueFamilyQueryResultStatusPropertiesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -5266,8 +6594,8 @@ void transform_fromhost_VkVideoQueueFamilyProperties2KHR(
     }
 }
 
-void transform_tohost_VkVideoProfileKHR(VkDecoderGlobalState* resourceTracker,
-                                        VkVideoProfileKHR* toTransform) {
+void transform_tohost_VkQueueFamilyVideoPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkQueueFamilyVideoPropertiesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -5275,8 +6603,8 @@ void transform_tohost_VkVideoProfileKHR(VkDecoderGlobalState* resourceTracker,
     }
 }
 
-void transform_fromhost_VkVideoProfileKHR(VkDecoderGlobalState* resourceTracker,
-                                          VkVideoProfileKHR* toTransform) {
+void transform_fromhost_VkQueueFamilyVideoPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkQueueFamilyVideoPropertiesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -5284,29 +6612,55 @@ void transform_fromhost_VkVideoProfileKHR(VkDecoderGlobalState* resourceTracker,
     }
 }
 
-void transform_tohost_VkVideoProfilesKHR(VkDecoderGlobalState* resourceTracker,
-                                         VkVideoProfilesKHR* toTransform) {
+void transform_tohost_VkVideoProfileInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                            VkVideoProfileInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pProfiles) {
-        transform_tohost_VkVideoProfileKHR(resourceTracker,
-                                           (VkVideoProfileKHR*)(toTransform->pProfiles));
+}
+
+void transform_fromhost_VkVideoProfileInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                              VkVideoProfileInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
 }
 
-void transform_fromhost_VkVideoProfilesKHR(VkDecoderGlobalState* resourceTracker,
-                                           VkVideoProfilesKHR* toTransform) {
+void transform_tohost_VkVideoProfileListInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                VkVideoProfileListInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pProfiles) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->profileCount; ++i) {
+                transform_tohost_VkVideoProfileInfoKHR(
+                    resourceTracker, (VkVideoProfileInfoKHR*)(toTransform->pProfiles + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkVideoProfileListInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                  VkVideoProfileListInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pProfiles) {
-        transform_fromhost_VkVideoProfileKHR(resourceTracker,
-                                             (VkVideoProfileKHR*)(toTransform->pProfiles));
+    if (toTransform) {
+        if (toTransform->pProfiles) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->profileCount; ++i) {
+                transform_fromhost_VkVideoProfileInfoKHR(
+                    resourceTracker, (VkVideoProfileInfoKHR*)(toTransform->pProfiles + i));
+            }
+        }
     }
 }
 
@@ -5318,9 +6672,11 @@ void transform_tohost_VkVideoCapabilitiesKHR(VkDecoderGlobalState* resourceTrack
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
     transform_tohost_VkExtent2D(resourceTracker,
-                                (VkExtent2D*)(&toTransform->videoPictureExtentGranularity));
-    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minExtent));
-    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxExtent));
+                                (VkExtent2D*)(&toTransform->pictureAccessGranularity));
+    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minCodedExtent));
+    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxCodedExtent));
+    transform_tohost_VkExtensionProperties(
+        resourceTracker, (VkExtensionProperties*)(&toTransform->stdHeaderVersion));
 }
 
 void transform_fromhost_VkVideoCapabilitiesKHR(VkDecoderGlobalState* resourceTracker,
@@ -5331,9 +6687,11 @@ void transform_fromhost_VkVideoCapabilitiesKHR(VkDecoderGlobalState* resourceTra
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
     transform_fromhost_VkExtent2D(resourceTracker,
-                                  (VkExtent2D*)(&toTransform->videoPictureExtentGranularity));
-    transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minExtent));
-    transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxExtent));
+                                  (VkExtent2D*)(&toTransform->pictureAccessGranularity));
+    transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minCodedExtent));
+    transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxCodedExtent));
+    transform_fromhost_VkExtensionProperties(
+        resourceTracker, (VkExtensionProperties*)(&toTransform->stdHeaderVersion));
 }
 
 void transform_tohost_VkPhysicalDeviceVideoFormatInfoKHR(
@@ -5343,10 +6701,6 @@ void transform_tohost_VkPhysicalDeviceVideoFormatInfoKHR(
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pVideoProfiles) {
-        transform_tohost_VkVideoProfilesKHR(resourceTracker,
-                                            (VkVideoProfilesKHR*)(toTransform->pVideoProfiles));
-    }
 }
 
 void transform_fromhost_VkPhysicalDeviceVideoFormatInfoKHR(
@@ -5356,10 +6710,6 @@ void transform_fromhost_VkPhysicalDeviceVideoFormatInfoKHR(
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pVideoProfiles) {
-        transform_fromhost_VkVideoProfilesKHR(resourceTracker,
-                                              (VkVideoProfilesKHR*)(toTransform->pVideoProfiles));
-    }
 }
 
 void transform_tohost_VkVideoFormatPropertiesKHR(VkDecoderGlobalState* resourceTracker,
@@ -5369,6 +6719,8 @@ void transform_tohost_VkVideoFormatPropertiesKHR(VkDecoderGlobalState* resourceT
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
+    transform_tohost_VkComponentMapping(resourceTracker,
+                                        (VkComponentMapping*)(&toTransform->componentMapping));
 }
 
 void transform_fromhost_VkVideoFormatPropertiesKHR(VkDecoderGlobalState* resourceTracker,
@@ -5378,10 +6730,12 @@ void transform_fromhost_VkVideoFormatPropertiesKHR(VkDecoderGlobalState* resourc
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
+    transform_fromhost_VkComponentMapping(resourceTracker,
+                                          (VkComponentMapping*)(&toTransform->componentMapping));
 }
 
-void transform_tohost_VkVideoPictureResourceKHR(VkDecoderGlobalState* resourceTracker,
-                                                VkVideoPictureResourceKHR* toTransform) {
+void transform_tohost_VkVideoPictureResourceInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                    VkVideoPictureResourceInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -5391,8 +6745,8 @@ void transform_tohost_VkVideoPictureResourceKHR(VkDecoderGlobalState* resourceTr
     transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->codedExtent));
 }
 
-void transform_fromhost_VkVideoPictureResourceKHR(VkDecoderGlobalState* resourceTracker,
-                                                  VkVideoPictureResourceKHR* toTransform) {
+void transform_fromhost_VkVideoPictureResourceInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoPictureResourceInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -5402,60 +6756,56 @@ void transform_fromhost_VkVideoPictureResourceKHR(VkDecoderGlobalState* resource
     transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->codedExtent));
 }
 
-void transform_tohost_VkVideoReferenceSlotKHR(VkDecoderGlobalState* resourceTracker,
-                                              VkVideoReferenceSlotKHR* toTransform) {
+void transform_tohost_VkVideoReferenceSlotInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                  VkVideoReferenceSlotInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
     if (toTransform->pPictureResource) {
-        transform_tohost_VkVideoPictureResourceKHR(
-            resourceTracker, (VkVideoPictureResourceKHR*)(toTransform->pPictureResource));
+        transform_tohost_VkVideoPictureResourceInfoKHR(
+            resourceTracker, (VkVideoPictureResourceInfoKHR*)(toTransform->pPictureResource));
     }
 }
 
-void transform_fromhost_VkVideoReferenceSlotKHR(VkDecoderGlobalState* resourceTracker,
-                                                VkVideoReferenceSlotKHR* toTransform) {
+void transform_fromhost_VkVideoReferenceSlotInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                    VkVideoReferenceSlotInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
     if (toTransform->pPictureResource) {
-        transform_fromhost_VkVideoPictureResourceKHR(
-            resourceTracker, (VkVideoPictureResourceKHR*)(toTransform->pPictureResource));
+        transform_fromhost_VkVideoPictureResourceInfoKHR(
+            resourceTracker, (VkVideoPictureResourceInfoKHR*)(toTransform->pPictureResource));
     }
 }
 
-void transform_tohost_VkVideoGetMemoryPropertiesKHR(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoGetMemoryPropertiesKHR* toTransform) {
+void transform_tohost_VkVideoSessionMemoryRequirementsKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoSessionMemoryRequirementsKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pMemoryRequirements) {
-        transform_tohost_VkMemoryRequirements2(
-            resourceTracker, (VkMemoryRequirements2*)(toTransform->pMemoryRequirements));
-    }
+    transform_tohost_VkMemoryRequirements(
+        resourceTracker, (VkMemoryRequirements*)(&toTransform->memoryRequirements));
 }
 
-void transform_fromhost_VkVideoGetMemoryPropertiesKHR(VkDecoderGlobalState* resourceTracker,
-                                                      VkVideoGetMemoryPropertiesKHR* toTransform) {
+void transform_fromhost_VkVideoSessionMemoryRequirementsKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoSessionMemoryRequirementsKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pMemoryRequirements) {
-        transform_fromhost_VkMemoryRequirements2(
-            resourceTracker, (VkMemoryRequirements2*)(toTransform->pMemoryRequirements));
-    }
+    transform_fromhost_VkMemoryRequirements(
+        resourceTracker, (VkMemoryRequirements*)(&toTransform->memoryRequirements));
 }
 
-void transform_tohost_VkVideoBindMemoryKHR(VkDecoderGlobalState* resourceTracker,
-                                           VkVideoBindMemoryKHR* toTransform) {
+void transform_tohost_VkBindVideoSessionMemoryInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkBindVideoSessionMemoryInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -5463,8 +6813,8 @@ void transform_tohost_VkVideoBindMemoryKHR(VkDecoderGlobalState* resourceTracker
     }
 }
 
-void transform_fromhost_VkVideoBindMemoryKHR(VkDecoderGlobalState* resourceTracker,
-                                             VkVideoBindMemoryKHR* toTransform) {
+void transform_fromhost_VkBindVideoSessionMemoryInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkBindVideoSessionMemoryInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -5480,10 +6830,14 @@ void transform_tohost_VkVideoSessionCreateInfoKHR(VkDecoderGlobalState* resource
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
     if (toTransform->pVideoProfile) {
-        transform_tohost_VkVideoProfileKHR(resourceTracker,
-                                           (VkVideoProfileKHR*)(toTransform->pVideoProfile));
+        transform_tohost_VkVideoProfileInfoKHR(
+            resourceTracker, (VkVideoProfileInfoKHR*)(toTransform->pVideoProfile));
     }
     transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxCodedExtent));
+    if (toTransform->pStdHeaderVersion) {
+        transform_tohost_VkExtensionProperties(
+            resourceTracker, (VkExtensionProperties*)(toTransform->pStdHeaderVersion));
+    }
 }
 
 void transform_fromhost_VkVideoSessionCreateInfoKHR(VkDecoderGlobalState* resourceTracker,
@@ -5494,10 +6848,14 @@ void transform_fromhost_VkVideoSessionCreateInfoKHR(VkDecoderGlobalState* resour
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
     if (toTransform->pVideoProfile) {
-        transform_fromhost_VkVideoProfileKHR(resourceTracker,
-                                             (VkVideoProfileKHR*)(toTransform->pVideoProfile));
+        transform_fromhost_VkVideoProfileInfoKHR(
+            resourceTracker, (VkVideoProfileInfoKHR*)(toTransform->pVideoProfile));
     }
     transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxCodedExtent));
+    if (toTransform->pStdHeaderVersion) {
+        transform_fromhost_VkExtensionProperties(
+            resourceTracker, (VkExtensionProperties*)(toTransform->pStdHeaderVersion));
+    }
 }
 
 void transform_tohost_VkVideoSessionParametersCreateInfoKHR(
@@ -5546,8 +6904,9 @@ void transform_tohost_VkVideoBeginCodingInfoKHR(VkDecoderGlobalState* resourceTr
     if (toTransform) {
         if (toTransform->pReferenceSlots) {
             for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i) {
-                transform_tohost_VkVideoReferenceSlotKHR(
-                    resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
+                transform_tohost_VkVideoReferenceSlotInfoKHR(
+                    resourceTracker,
+                    (VkVideoReferenceSlotInfoKHR*)(toTransform->pReferenceSlots + i));
             }
         }
     }
@@ -5563,8 +6922,9 @@ void transform_fromhost_VkVideoBeginCodingInfoKHR(VkDecoderGlobalState* resource
     if (toTransform) {
         if (toTransform->pReferenceSlots) {
             for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i) {
-                transform_fromhost_VkVideoReferenceSlotKHR(
-                    resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
+                transform_fromhost_VkVideoReferenceSlotInfoKHR(
+                    resourceTracker,
+                    (VkVideoReferenceSlotInfoKHR*)(toTransform->pReferenceSlots + i));
             }
         }
     }
@@ -5608,6 +6968,42 @@ void transform_fromhost_VkVideoCodingControlInfoKHR(VkDecoderGlobalState* resour
 
 #endif
 #ifdef VK_KHR_video_decode_queue
+void transform_tohost_VkVideoDecodeCapabilitiesKHR(VkDecoderGlobalState* resourceTracker,
+                                                   VkVideoDecodeCapabilitiesKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkVideoDecodeCapabilitiesKHR(VkDecoderGlobalState* resourceTracker,
+                                                     VkVideoDecodeCapabilitiesKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkVideoDecodeUsageInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                VkVideoDecodeUsageInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkVideoDecodeUsageInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                  VkVideoDecodeUsageInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
 void transform_tohost_VkVideoDecodeInfoKHR(VkDecoderGlobalState* resourceTracker,
                                            VkVideoDecodeInfoKHR* toTransform) {
     (void)resourceTracker;
@@ -5615,19 +7011,18 @@ void transform_tohost_VkVideoDecodeInfoKHR(VkDecoderGlobalState* resourceTracker
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_tohost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->codedOffset));
-    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->codedExtent));
-    transform_tohost_VkVideoPictureResourceKHR(
-        resourceTracker, (VkVideoPictureResourceKHR*)(&toTransform->dstPictureResource));
+    transform_tohost_VkVideoPictureResourceInfoKHR(
+        resourceTracker, (VkVideoPictureResourceInfoKHR*)(&toTransform->dstPictureResource));
     if (toTransform->pSetupReferenceSlot) {
-        transform_tohost_VkVideoReferenceSlotKHR(
-            resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pSetupReferenceSlot));
+        transform_tohost_VkVideoReferenceSlotInfoKHR(
+            resourceTracker, (VkVideoReferenceSlotInfoKHR*)(toTransform->pSetupReferenceSlot));
     }
     if (toTransform) {
         if (toTransform->pReferenceSlots) {
             for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i) {
-                transform_tohost_VkVideoReferenceSlotKHR(
-                    resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
+                transform_tohost_VkVideoReferenceSlotInfoKHR(
+                    resourceTracker,
+                    (VkVideoReferenceSlotInfoKHR*)(toTransform->pReferenceSlots + i));
             }
         }
     }
@@ -5640,102 +7035,68 @@ void transform_fromhost_VkVideoDecodeInfoKHR(VkDecoderGlobalState* resourceTrack
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_fromhost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->codedOffset));
-    transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->codedExtent));
-    transform_fromhost_VkVideoPictureResourceKHR(
-        resourceTracker, (VkVideoPictureResourceKHR*)(&toTransform->dstPictureResource));
+    transform_fromhost_VkVideoPictureResourceInfoKHR(
+        resourceTracker, (VkVideoPictureResourceInfoKHR*)(&toTransform->dstPictureResource));
     if (toTransform->pSetupReferenceSlot) {
-        transform_fromhost_VkVideoReferenceSlotKHR(
-            resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pSetupReferenceSlot));
+        transform_fromhost_VkVideoReferenceSlotInfoKHR(
+            resourceTracker, (VkVideoReferenceSlotInfoKHR*)(toTransform->pSetupReferenceSlot));
     }
     if (toTransform) {
         if (toTransform->pReferenceSlots) {
             for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i) {
-                transform_fromhost_VkVideoReferenceSlotKHR(
-                    resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
+                transform_fromhost_VkVideoReferenceSlotInfoKHR(
+                    resourceTracker,
+                    (VkVideoReferenceSlotInfoKHR*)(toTransform->pReferenceSlots + i));
             }
         }
     }
 }
 
 #endif
-#ifdef VK_KHR_dynamic_rendering
-void transform_tohost_VkRenderingAttachmentInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                                   VkRenderingAttachmentInfoKHR* toTransform) {
+#ifdef VK_KHR_video_decode_h264
+void transform_tohost_VkVideoDecodeH264ProfileInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264ProfileInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_tohost_VkClearValue(resourceTracker, (VkClearValue*)(&toTransform->clearValue));
 }
 
-void transform_fromhost_VkRenderingAttachmentInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                                     VkRenderingAttachmentInfoKHR* toTransform) {
+void transform_fromhost_VkVideoDecodeH264ProfileInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264ProfileInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_fromhost_VkClearValue(resourceTracker, (VkClearValue*)(&toTransform->clearValue));
 }
 
-void transform_tohost_VkRenderingInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                         VkRenderingInfoKHR* toTransform) {
+void transform_tohost_VkVideoDecodeH264CapabilitiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264CapabilitiesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->renderArea));
-    if (toTransform) {
-        if (toTransform->pColorAttachments) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
-                transform_tohost_VkRenderingAttachmentInfoKHR(
-                    resourceTracker,
-                    (VkRenderingAttachmentInfoKHR*)(toTransform->pColorAttachments + i));
-            }
-        }
-    }
-    if (toTransform->pDepthAttachment) {
-        transform_tohost_VkRenderingAttachmentInfoKHR(
-            resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pDepthAttachment));
-    }
-    if (toTransform->pStencilAttachment) {
-        transform_tohost_VkRenderingAttachmentInfoKHR(
-            resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pStencilAttachment));
-    }
+    transform_tohost_VkOffset2D(resourceTracker,
+                                (VkOffset2D*)(&toTransform->fieldOffsetGranularity));
 }
 
-void transform_fromhost_VkRenderingInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                           VkRenderingInfoKHR* toTransform) {
+void transform_fromhost_VkVideoDecodeH264CapabilitiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264CapabilitiesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_fromhost_VkRect2D(resourceTracker, (VkRect2D*)(&toTransform->renderArea));
-    if (toTransform) {
-        if (toTransform->pColorAttachments) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->colorAttachmentCount; ++i) {
-                transform_fromhost_VkRenderingAttachmentInfoKHR(
-                    resourceTracker,
-                    (VkRenderingAttachmentInfoKHR*)(toTransform->pColorAttachments + i));
-            }
-        }
-    }
-    if (toTransform->pDepthAttachment) {
-        transform_fromhost_VkRenderingAttachmentInfoKHR(
-            resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pDepthAttachment));
-    }
-    if (toTransform->pStencilAttachment) {
-        transform_fromhost_VkRenderingAttachmentInfoKHR(
-            resourceTracker, (VkRenderingAttachmentInfoKHR*)(toTransform->pStencilAttachment));
-    }
+    transform_fromhost_VkOffset2D(resourceTracker,
+                                  (VkOffset2D*)(&toTransform->fieldOffsetGranularity));
 }
 
-void transform_tohost_VkPipelineRenderingCreateInfoKHR(
-    VkDecoderGlobalState* resourceTracker, VkPipelineRenderingCreateInfoKHR* toTransform) {
+void transform_tohost_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkVideoDecodeH264SessionParametersAddInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -5743,8 +7104,9 @@ void transform_tohost_VkPipelineRenderingCreateInfoKHR(
     }
 }
 
-void transform_fromhost_VkPipelineRenderingCreateInfoKHR(
-    VkDecoderGlobalState* resourceTracker, VkPipelineRenderingCreateInfoKHR* toTransform) {
+void transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkVideoDecodeH264SessionParametersAddInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -5752,29 +7114,38 @@ void transform_fromhost_VkPipelineRenderingCreateInfoKHR(
     }
 }
 
-void transform_tohost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+void transform_tohost_VkVideoDecodeH264SessionParametersCreateInfoKHR(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceDynamicRenderingFeaturesKHR* toTransform) {
+    VkVideoDecodeH264SessionParametersCreateInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
+    if (toTransform->pParametersAddInfo) {
+        transform_tohost_VkVideoDecodeH264SessionParametersAddInfoKHR(
+            resourceTracker,
+            (VkVideoDecodeH264SessionParametersAddInfoKHR*)(toTransform->pParametersAddInfo));
+    }
 }
 
-void transform_fromhost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+void transform_fromhost_VkVideoDecodeH264SessionParametersCreateInfoKHR(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceDynamicRenderingFeaturesKHR* toTransform) {
+    VkVideoDecodeH264SessionParametersCreateInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
+    if (toTransform->pParametersAddInfo) {
+        transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoKHR(
+            resourceTracker,
+            (VkVideoDecodeH264SessionParametersAddInfoKHR*)(toTransform->pParametersAddInfo));
+    }
 }
 
-void transform_tohost_VkCommandBufferInheritanceRenderingInfoKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkCommandBufferInheritanceRenderingInfoKHR* toTransform) {
+void transform_tohost_VkVideoDecodeH264PictureInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264PictureInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -5782,9 +7153,26 @@ void transform_tohost_VkCommandBufferInheritanceRenderingInfoKHR(
     }
 }
 
-void transform_fromhost_VkCommandBufferInheritanceRenderingInfoKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkCommandBufferInheritanceRenderingInfoKHR* toTransform) {
+void transform_fromhost_VkVideoDecodeH264PictureInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264PictureInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkVideoDecodeH264DpbSlotInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264DpbSlotInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkVideoDecodeH264DpbSlotInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264DpbSlotInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -5792,6 +7180,8 @@ void transform_fromhost_VkCommandBufferInheritanceRenderingInfoKHR(
     }
 }
 
+#endif
+#ifdef VK_KHR_dynamic_rendering
 void transform_tohost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
     VkDecoderGlobalState* resourceTracker,
     VkRenderingFragmentShadingRateAttachmentInfoKHR* toTransform) {
@@ -6048,6 +7438,10 @@ void transform_tohost_VkWin32KeyedMutexAcquireReleaseInfoKHR(
     VkDecoderGlobalState* resourceTracker, VkWin32KeyedMutexAcquireReleaseInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
+    resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)toTransform->pAcquireSyncs,
+                                                  toTransform->acquireCount, (VkDeviceSize*)nullptr,
+                                                  0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr,
+                                                  0, (uint32_t*)nullptr, 0);
     resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)toTransform->pReleaseSyncs,
                                                   toTransform->releaseCount, (VkDeviceSize*)nullptr,
                                                   0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr,
@@ -6062,6 +7456,10 @@ void transform_fromhost_VkWin32KeyedMutexAcquireReleaseInfoKHR(
     (void)resourceTracker;
     (void)toTransform;
     resourceTracker->deviceMemoryTransform_fromhost(
+        (VkDeviceMemory*)toTransform->pAcquireSyncs, toTransform->acquireCount,
+        (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0,
+        (uint32_t*)nullptr, 0);
+    resourceTracker->deviceMemoryTransform_fromhost(
         (VkDeviceMemory*)toTransform->pReleaseSyncs, toTransform->releaseCount,
         (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0,
         (uint32_t*)nullptr, 0);
@@ -6823,22 +8221,152 @@ void transform_fromhost_VkPhysicalDeviceShaderClockFeaturesKHR(
 }
 
 #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
+#ifdef VK_KHR_video_decode_h265
+void transform_tohost_VkVideoDecodeH265ProfileInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265ProfileInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkVideoDecodeH265ProfileInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265ProfileInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkVideoDecodeH265CapabilitiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265CapabilitiesKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkVideoDecodeH265CapabilitiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265CapabilitiesKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkVideoDecodeH265SessionParametersAddInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkVideoDecodeH265SessionParametersAddInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkVideoDecodeH265SessionParametersCreateInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pParametersAddInfo) {
+        transform_tohost_VkVideoDecodeH265SessionParametersAddInfoKHR(
+            resourceTracker,
+            (VkVideoDecodeH265SessionParametersAddInfoKHR*)(toTransform->pParametersAddInfo));
+    }
+}
+
+void transform_fromhost_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkVideoDecodeH265SessionParametersCreateInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pParametersAddInfo) {
+        transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoKHR(
+            resourceTracker,
+            (VkVideoDecodeH265SessionParametersAddInfoKHR*)(toTransform->pParametersAddInfo));
+    }
+}
+
+void transform_tohost_VkVideoDecodeH265PictureInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265PictureInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkVideoDecodeH265PictureInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265PictureInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkVideoDecodeH265DpbSlotInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265DpbSlotInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkVideoDecodeH265DpbSlotInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265DpbSlotInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
 #endif
-#ifdef VK_KHR_shader_terminate_invocation
-void transform_tohost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+#ifdef VK_KHR_global_priority
+void transform_tohost_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfoKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toTransform) {
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -6846,9 +8374,27 @@ void transform_tohost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
     }
 }
 
-void transform_fromhost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+void transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toTransform) {
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkQueueFamilyGlobalPriorityPropertiesKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkQueueFamilyGlobalPriorityPropertiesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -6857,6 +8403,20 @@ void transform_fromhost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
 }
 
 #endif
+#ifdef VK_KHR_driver_properties
+#endif
+#ifdef VK_KHR_shader_float_controls
+#endif
+#ifdef VK_KHR_depth_stencil_resolve
+#endif
+#ifdef VK_KHR_swapchain_mutable_format
+#endif
+#ifdef VK_KHR_timeline_semaphore
+#endif
+#ifdef VK_KHR_vulkan_memory_model
+#endif
+#ifdef VK_KHR_shader_terminate_invocation
+#endif
 #ifdef VK_KHR_fragment_shading_rate
 void transform_tohost_VkFragmentShadingRateAttachmentInfoKHR(
     VkDecoderGlobalState* resourceTracker, VkFragmentShadingRateAttachmentInfoKHR* toTransform) {
@@ -7163,10 +8723,9 @@ void transform_fromhost_VkPipelineExecutableInternalRepresentationKHR(
 }
 
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-void transform_tohost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toTransform) {
+#ifdef VK_KHR_map_memory2
+void transform_tohost_VkMemoryMapInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                         VkMemoryMapInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7174,9 +8733,8 @@ void transform_tohost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
     }
 }
 
-void transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toTransform) {
+void transform_fromhost_VkMemoryMapInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                           VkMemoryMapInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7184,9 +8742,8 @@ void transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
     }
 }
 
-void transform_tohost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toTransform) {
+void transform_tohost_VkMemoryUnmapInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                           VkMemoryUnmapInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7194,9 +8751,8 @@ void transform_tohost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
     }
 }
 
-void transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toTransform) {
+void transform_fromhost_VkMemoryUnmapInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                             VkMemoryUnmapInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7205,6 +8761,8 @@ void transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
 }
 
 #endif
+#ifdef VK_KHR_shader_integer_dot_product
+#endif
 #ifdef VK_KHR_pipeline_library
 void transform_tohost_VkPipelineLibraryCreateInfoKHR(VkDecoderGlobalState* resourceTracker,
                                                      VkPipelineLibraryCreateInfoKHR* toTransform) {
@@ -7273,18 +8831,18 @@ void transform_tohost_VkVideoEncodeInfoKHR(VkDecoderGlobalState* resourceTracker
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->codedExtent));
-    transform_tohost_VkVideoPictureResourceKHR(
-        resourceTracker, (VkVideoPictureResourceKHR*)(&toTransform->srcPictureResource));
+    transform_tohost_VkVideoPictureResourceInfoKHR(
+        resourceTracker, (VkVideoPictureResourceInfoKHR*)(&toTransform->srcPictureResource));
     if (toTransform->pSetupReferenceSlot) {
-        transform_tohost_VkVideoReferenceSlotKHR(
-            resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pSetupReferenceSlot));
+        transform_tohost_VkVideoReferenceSlotInfoKHR(
+            resourceTracker, (VkVideoReferenceSlotInfoKHR*)(toTransform->pSetupReferenceSlot));
     }
     if (toTransform) {
         if (toTransform->pReferenceSlots) {
             for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i) {
-                transform_tohost_VkVideoReferenceSlotKHR(
-                    resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
+                transform_tohost_VkVideoReferenceSlotInfoKHR(
+                    resourceTracker,
+                    (VkVideoReferenceSlotInfoKHR*)(toTransform->pReferenceSlots + i));
             }
         }
     }
@@ -7297,45 +8855,48 @@ void transform_fromhost_VkVideoEncodeInfoKHR(VkDecoderGlobalState* resourceTrack
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->codedExtent));
-    transform_fromhost_VkVideoPictureResourceKHR(
-        resourceTracker, (VkVideoPictureResourceKHR*)(&toTransform->srcPictureResource));
+    transform_fromhost_VkVideoPictureResourceInfoKHR(
+        resourceTracker, (VkVideoPictureResourceInfoKHR*)(&toTransform->srcPictureResource));
     if (toTransform->pSetupReferenceSlot) {
-        transform_fromhost_VkVideoReferenceSlotKHR(
-            resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pSetupReferenceSlot));
+        transform_fromhost_VkVideoReferenceSlotInfoKHR(
+            resourceTracker, (VkVideoReferenceSlotInfoKHR*)(toTransform->pSetupReferenceSlot));
     }
     if (toTransform) {
         if (toTransform->pReferenceSlots) {
             for (uint32_t i = 0; i < (uint32_t)toTransform->referenceSlotCount; ++i) {
-                transform_fromhost_VkVideoReferenceSlotKHR(
-                    resourceTracker, (VkVideoReferenceSlotKHR*)(toTransform->pReferenceSlots + i));
+                transform_fromhost_VkVideoReferenceSlotInfoKHR(
+                    resourceTracker,
+                    (VkVideoReferenceSlotInfoKHR*)(toTransform->pReferenceSlots + i));
             }
         }
     }
 }
 
-void transform_tohost_VkVideoEncodeRateControlInfoKHR(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeRateControlInfoKHR* toTransform) {
+void transform_tohost_VkVideoEncodeCapabilitiesKHR(VkDecoderGlobalState* resourceTracker,
+                                                   VkVideoEncodeCapabilitiesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
+    transform_tohost_VkExtent2D(resourceTracker,
+                                (VkExtent2D*)(&toTransform->inputImageDataFillAlignment));
 }
 
-void transform_fromhost_VkVideoEncodeRateControlInfoKHR(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeRateControlInfoKHR* toTransform) {
+void transform_fromhost_VkVideoEncodeCapabilitiesKHR(VkDecoderGlobalState* resourceTracker,
+                                                     VkVideoEncodeCapabilitiesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
+    transform_fromhost_VkExtent2D(resourceTracker,
+                                  (VkExtent2D*)(&toTransform->inputImageDataFillAlignment));
 }
 
-#endif
-#ifdef VK_KHR_synchronization2
-void transform_tohost_VkMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracker,
-                                          VkMemoryBarrier2KHR* toTransform) {
+void transform_tohost_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7343,8 +8904,9 @@ void transform_tohost_VkMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracker,
     }
 }
 
-void transform_fromhost_VkMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracker,
-                                            VkMemoryBarrier2KHR* toTransform) {
+void transform_fromhost_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7352,8 +8914,8 @@ void transform_fromhost_VkMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracke
     }
 }
 
-void transform_tohost_VkBufferMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracker,
-                                                VkBufferMemoryBarrier2KHR* toTransform) {
+void transform_tohost_VkVideoEncodeUsageInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                VkVideoEncodeUsageInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7361,8 +8923,8 @@ void transform_tohost_VkBufferMemoryBarrier2KHR(VkDecoderGlobalState* resourceTr
     }
 }
 
-void transform_fromhost_VkBufferMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracker,
-                                                  VkBufferMemoryBarrier2KHR* toTransform) {
+void transform_fromhost_VkVideoEncodeUsageInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                  VkVideoEncodeUsageInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7370,118 +8932,64 @@ void transform_fromhost_VkBufferMemoryBarrier2KHR(VkDecoderGlobalState* resource
     }
 }
 
-void transform_tohost_VkImageMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracker,
-                                               VkImageMemoryBarrier2KHR* toTransform) {
+void transform_tohost_VkVideoEncodeRateControlLayerInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeRateControlLayerInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_tohost_VkImageSubresourceRange(
-        resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
 }
 
-void transform_fromhost_VkImageMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracker,
-                                                 VkImageMemoryBarrier2KHR* toTransform) {
+void transform_fromhost_VkVideoEncodeRateControlLayerInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeRateControlLayerInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_fromhost_VkImageSubresourceRange(
-        resourceTracker, (VkImageSubresourceRange*)(&toTransform->subresourceRange));
 }
 
-void transform_tohost_VkDependencyInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                          VkDependencyInfoKHR* toTransform) {
+void transform_tohost_VkVideoEncodeRateControlInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeRateControlInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
     if (toTransform) {
-        if (toTransform->pMemoryBarriers) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->memoryBarrierCount; ++i) {
-                transform_tohost_VkMemoryBarrier2KHR(
-                    resourceTracker, (VkMemoryBarrier2KHR*)(toTransform->pMemoryBarriers + i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pBufferMemoryBarriers) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->bufferMemoryBarrierCount; ++i) {
-                transform_tohost_VkBufferMemoryBarrier2KHR(
+        if (toTransform->pLayers) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->layerCount; ++i) {
+                transform_tohost_VkVideoEncodeRateControlLayerInfoKHR(
                     resourceTracker,
-                    (VkBufferMemoryBarrier2KHR*)(toTransform->pBufferMemoryBarriers + i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pImageMemoryBarriers) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->imageMemoryBarrierCount; ++i) {
-                transform_tohost_VkImageMemoryBarrier2KHR(
-                    resourceTracker,
-                    (VkImageMemoryBarrier2KHR*)(toTransform->pImageMemoryBarriers + i));
+                    (VkVideoEncodeRateControlLayerInfoKHR*)(toTransform->pLayers + i));
             }
         }
     }
 }
 
-void transform_fromhost_VkDependencyInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                            VkDependencyInfoKHR* toTransform) {
+void transform_fromhost_VkVideoEncodeRateControlInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeRateControlInfoKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
     if (toTransform) {
-        if (toTransform->pMemoryBarriers) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->memoryBarrierCount; ++i) {
-                transform_fromhost_VkMemoryBarrier2KHR(
-                    resourceTracker, (VkMemoryBarrier2KHR*)(toTransform->pMemoryBarriers + i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pBufferMemoryBarriers) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->bufferMemoryBarrierCount; ++i) {
-                transform_fromhost_VkBufferMemoryBarrier2KHR(
+        if (toTransform->pLayers) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->layerCount; ++i) {
+                transform_fromhost_VkVideoEncodeRateControlLayerInfoKHR(
                     resourceTracker,
-                    (VkBufferMemoryBarrier2KHR*)(toTransform->pBufferMemoryBarriers + i));
+                    (VkVideoEncodeRateControlLayerInfoKHR*)(toTransform->pLayers + i));
             }
         }
     }
-    if (toTransform) {
-        if (toTransform->pImageMemoryBarriers) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->imageMemoryBarrierCount; ++i) {
-                transform_fromhost_VkImageMemoryBarrier2KHR(
-                    resourceTracker,
-                    (VkImageMemoryBarrier2KHR*)(toTransform->pImageMemoryBarriers + i));
-            }
-        }
-    }
-}
-
-void transform_tohost_VkSemaphoreSubmitInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                               VkSemaphoreSubmitInfoKHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
 }
 
-void transform_fromhost_VkSemaphoreSubmitInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                                 VkSemaphoreSubmitInfoKHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_tohost_VkCommandBufferSubmitInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                                   VkCommandBufferSubmitInfoKHR* toTransform) {
+#endif
+#ifdef VK_KHR_synchronization2
+void transform_tohost_VkQueueFamilyCheckpointProperties2NV(
+    VkDecoderGlobalState* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7489,8 +8997,8 @@ void transform_tohost_VkCommandBufferSubmitInfoKHR(VkDecoderGlobalState* resourc
     }
 }
 
-void transform_fromhost_VkCommandBufferSubmitInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                                     VkCommandBufferSubmitInfoKHR* toTransform) {
+void transform_fromhost_VkQueueFamilyCheckpointProperties2NV(
+    VkDecoderGlobalState* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7498,81 +9006,29 @@ void transform_fromhost_VkCommandBufferSubmitInfoKHR(VkDecoderGlobalState* resou
     }
 }
 
-void transform_tohost_VkSubmitInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                       VkSubmitInfo2KHR* toTransform) {
+void transform_tohost_VkCheckpointData2NV(VkDecoderGlobalState* resourceTracker,
+                                          VkCheckpointData2NV* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform) {
-        if (toTransform->pWaitSemaphoreInfos) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->waitSemaphoreInfoCount; ++i) {
-                transform_tohost_VkSemaphoreSubmitInfoKHR(
-                    resourceTracker,
-                    (VkSemaphoreSubmitInfoKHR*)(toTransform->pWaitSemaphoreInfos + i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pCommandBufferInfos) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->commandBufferInfoCount; ++i) {
-                transform_tohost_VkCommandBufferSubmitInfoKHR(
-                    resourceTracker,
-                    (VkCommandBufferSubmitInfoKHR*)(toTransform->pCommandBufferInfos + i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pSignalSemaphoreInfos) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->signalSemaphoreInfoCount; ++i) {
-                transform_tohost_VkSemaphoreSubmitInfoKHR(
-                    resourceTracker,
-                    (VkSemaphoreSubmitInfoKHR*)(toTransform->pSignalSemaphoreInfos + i));
-            }
-        }
-    }
 }
 
-void transform_fromhost_VkSubmitInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                         VkSubmitInfo2KHR* toTransform) {
+void transform_fromhost_VkCheckpointData2NV(VkDecoderGlobalState* resourceTracker,
+                                            VkCheckpointData2NV* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform) {
-        if (toTransform->pWaitSemaphoreInfos) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->waitSemaphoreInfoCount; ++i) {
-                transform_fromhost_VkSemaphoreSubmitInfoKHR(
-                    resourceTracker,
-                    (VkSemaphoreSubmitInfoKHR*)(toTransform->pWaitSemaphoreInfos + i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pCommandBufferInfos) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->commandBufferInfoCount; ++i) {
-                transform_fromhost_VkCommandBufferSubmitInfoKHR(
-                    resourceTracker,
-                    (VkCommandBufferSubmitInfoKHR*)(toTransform->pCommandBufferInfos + i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pSignalSemaphoreInfos) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->signalSemaphoreInfoCount; ++i) {
-                transform_fromhost_VkSemaphoreSubmitInfoKHR(
-                    resourceTracker,
-                    (VkSemaphoreSubmitInfoKHR*)(toTransform->pSignalSemaphoreInfos + i));
-            }
-        }
-    }
 }
 
-void transform_tohost_VkPhysicalDeviceSynchronization2FeaturesKHR(
+#endif
+#ifdef VK_KHR_fragment_shader_barycentric
+void transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceSynchronization2FeaturesKHR* toTransform) {
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7580,9 +9036,9 @@ void transform_tohost_VkPhysicalDeviceSynchronization2FeaturesKHR(
     }
 }
 
-void transform_fromhost_VkPhysicalDeviceSynchronization2FeaturesKHR(
+void transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceSynchronization2FeaturesKHR* toTransform) {
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7590,26 +9046,9 @@ void transform_fromhost_VkPhysicalDeviceSynchronization2FeaturesKHR(
     }
 }
 
-void transform_tohost_VkQueueFamilyCheckpointProperties2NV(
-    VkDecoderGlobalState* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkQueueFamilyCheckpointProperties2NV(
-    VkDecoderGlobalState* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_tohost_VkCheckpointData2NV(VkDecoderGlobalState* resourceTracker,
-                                          VkCheckpointData2NV* toTransform) {
+void transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7617,8 +9056,9 @@ void transform_tohost_VkCheckpointData2NV(VkDecoderGlobalState* resourceTracker,
     }
 }
 
-void transform_fromhost_VkCheckpointData2NV(VkDecoderGlobalState* resourceTracker,
-                                            VkCheckpointData2NV* toTransform) {
+void transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -7650,26 +9090,6 @@ void transform_fromhost_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeatures
 
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
-void transform_tohost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
 #endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
 void transform_tohost_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR(
@@ -7694,380 +9114,51 @@ void transform_fromhost_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
 
 #endif
 #ifdef VK_KHR_copy_commands2
-void transform_tohost_VkBufferCopy2KHR(VkDecoderGlobalState* resourceTracker,
-                                       VkBufferCopy2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkBufferCopy2KHR(VkDecoderGlobalState* resourceTracker,
-                                         VkBufferCopy2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_tohost_VkCopyBufferInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                           VkCopyBufferInfo2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
-                transform_tohost_VkBufferCopy2KHR(resourceTracker,
-                                                  (VkBufferCopy2KHR*)(toTransform->pRegions + i));
-            }
-        }
-    }
-}
-
-void transform_fromhost_VkCopyBufferInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                             VkCopyBufferInfo2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
-                transform_fromhost_VkBufferCopy2KHR(resourceTracker,
-                                                    (VkBufferCopy2KHR*)(toTransform->pRegions + i));
-            }
-        }
-    }
-}
-
-void transform_tohost_VkImageCopy2KHR(VkDecoderGlobalState* resourceTracker,
-                                      VkImageCopy2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_tohost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
-    transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
-    transform_tohost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
-    transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
-    transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
-}
-
-void transform_fromhost_VkImageCopy2KHR(VkDecoderGlobalState* resourceTracker,
-                                        VkImageCopy2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_fromhost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
-    transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
-    transform_fromhost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
-    transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
-    transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
-}
-
-void transform_tohost_VkCopyImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                          VkCopyImageInfo2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
-                transform_tohost_VkImageCopy2KHR(resourceTracker,
-                                                 (VkImageCopy2KHR*)(toTransform->pRegions + i));
-            }
-        }
-    }
-}
-
-void transform_fromhost_VkCopyImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                            VkCopyImageInfo2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
-                transform_fromhost_VkImageCopy2KHR(resourceTracker,
-                                                   (VkImageCopy2KHR*)(toTransform->pRegions + i));
-            }
-        }
-    }
-}
-
-void transform_tohost_VkBufferImageCopy2KHR(VkDecoderGlobalState* resourceTracker,
-                                            VkBufferImageCopy2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_tohost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
-    transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
-    transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
-}
-
-void transform_fromhost_VkBufferImageCopy2KHR(VkDecoderGlobalState* resourceTracker,
-                                              VkBufferImageCopy2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_fromhost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
-    transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
-    transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
-}
-
-void transform_tohost_VkCopyBufferToImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                                  VkCopyBufferToImageInfo2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
-                transform_tohost_VkBufferImageCopy2KHR(
-                    resourceTracker, (VkBufferImageCopy2KHR*)(toTransform->pRegions + i));
-            }
-        }
-    }
-}
-
-void transform_fromhost_VkCopyBufferToImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                                    VkCopyBufferToImageInfo2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
-                transform_fromhost_VkBufferImageCopy2KHR(
-                    resourceTracker, (VkBufferImageCopy2KHR*)(toTransform->pRegions + i));
-            }
-        }
-    }
-}
-
-void transform_tohost_VkCopyImageToBufferInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                                  VkCopyImageToBufferInfo2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
-                transform_tohost_VkBufferImageCopy2KHR(
-                    resourceTracker, (VkBufferImageCopy2KHR*)(toTransform->pRegions + i));
-            }
-        }
-    }
-}
-
-void transform_fromhost_VkCopyImageToBufferInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                                    VkCopyImageToBufferInfo2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
-                transform_fromhost_VkBufferImageCopy2KHR(
-                    resourceTracker, (VkBufferImageCopy2KHR*)(toTransform->pRegions + i));
-            }
-        }
-    }
-}
-
-void transform_tohost_VkImageBlit2KHR(VkDecoderGlobalState* resourceTracker,
-                                      VkImageBlit2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_tohost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->srcOffsets + i));
-    }
-    transform_tohost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->dstOffsets + i));
-    }
-}
-
-void transform_fromhost_VkImageBlit2KHR(VkDecoderGlobalState* resourceTracker,
-                                        VkImageBlit2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_fromhost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->srcOffsets + i));
-    }
-    transform_fromhost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
-    for (uint32_t i = 0; i < (uint32_t)2; ++i) {
-        transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(toTransform->dstOffsets + i));
-    }
-}
-
-void transform_tohost_VkBlitImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                          VkBlitImageInfo2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
-                transform_tohost_VkImageBlit2KHR(resourceTracker,
-                                                 (VkImageBlit2KHR*)(toTransform->pRegions + i));
-            }
-        }
-    }
-}
-
-void transform_fromhost_VkBlitImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                            VkBlitImageInfo2KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
-                transform_fromhost_VkImageBlit2KHR(resourceTracker,
-                                                   (VkImageBlit2KHR*)(toTransform->pRegions + i));
-            }
-        }
-    }
-}
-
-void transform_tohost_VkImageResolve2KHR(VkDecoderGlobalState* resourceTracker,
-                                         VkImageResolve2KHR* toTransform) {
+#endif
+#ifdef VK_KHR_format_feature_flags2
+#endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+void transform_tohost_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_tohost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
-    transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
-    transform_tohost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
-    transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
-    transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
 }
 
-void transform_fromhost_VkImageResolve2KHR(VkDecoderGlobalState* resourceTracker,
-                                           VkImageResolve2KHR* toTransform) {
+void transform_fromhost_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_fromhost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->srcSubresource));
-    transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->srcOffset));
-    transform_fromhost_VkImageSubresourceLayers(
-        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->dstSubresource));
-    transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->dstOffset));
-    transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->extent));
 }
 
-void transform_tohost_VkResolveImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                             VkResolveImageInfo2KHR* toTransform) {
+void transform_tohost_VkTraceRaysIndirectCommand2KHR(VkDecoderGlobalState* resourceTracker,
+                                                     VkTraceRaysIndirectCommand2KHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
-                transform_tohost_VkImageResolve2KHR(
-                    resourceTracker, (VkImageResolve2KHR*)(toTransform->pRegions + i));
-            }
-        }
-    }
 }
 
-void transform_fromhost_VkResolveImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                               VkResolveImageInfo2KHR* toTransform) {
+void transform_fromhost_VkTraceRaysIndirectCommand2KHR(
+    VkDecoderGlobalState* resourceTracker, VkTraceRaysIndirectCommand2KHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pRegions) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
-                transform_fromhost_VkImageResolve2KHR(
-                    resourceTracker, (VkImageResolve2KHR*)(toTransform->pRegions + i));
-            }
-        }
-    }
 }
 
 #endif
-#ifdef VK_KHR_format_feature_flags2
-void transform_tohost_VkFormatProperties3KHR(VkDecoderGlobalState* resourceTracker,
-                                             VkFormatProperties3KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkFormatProperties3KHR(VkDecoderGlobalState* resourceTracker,
-                                               VkFormatProperties3KHR* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
+#ifdef VK_KHR_portability_enumeration
 #endif
 #ifdef VK_KHR_maintenance4
-void transform_tohost_VkPhysicalDeviceMaintenance4FeaturesKHR(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4FeaturesKHR* toTransform) {
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+void transform_tohost_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -8075,8 +9166,9 @@ void transform_tohost_VkPhysicalDeviceMaintenance4FeaturesKHR(
     }
 }
 
-void transform_fromhost_VkPhysicalDeviceMaintenance4FeaturesKHR(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4FeaturesKHR* toTransform) {
+void transform_fromhost_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -8084,82 +9176,63 @@ void transform_fromhost_VkPhysicalDeviceMaintenance4FeaturesKHR(
     }
 }
 
-void transform_tohost_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4PropertiesKHR* toTransform) {
+#endif
+#ifdef VK_ANDROID_native_buffer
+void transform_tohost_VkNativeBufferUsage2ANDROID(VkDecoderGlobalState* resourceTracker,
+                                                  VkNativeBufferUsage2ANDROID* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
 }
 
-void transform_fromhost_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4PropertiesKHR* toTransform) {
+void transform_fromhost_VkNativeBufferUsage2ANDROID(VkDecoderGlobalState* resourceTracker,
+                                                    VkNativeBufferUsage2ANDROID* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
 }
 
-void transform_tohost_VkDeviceBufferMemoryRequirementsKHR(
-    VkDecoderGlobalState* resourceTracker, VkDeviceBufferMemoryRequirementsKHR* toTransform) {
+void transform_tohost_VkNativeBufferANDROID(VkDecoderGlobalState* resourceTracker,
+                                            VkNativeBufferANDROID* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pCreateInfo) {
-        transform_tohost_VkBufferCreateInfo(resourceTracker,
-                                            (VkBufferCreateInfo*)(toTransform->pCreateInfo));
-    }
+    transform_tohost_VkNativeBufferUsage2ANDROID(
+        resourceTracker, (VkNativeBufferUsage2ANDROID*)(&toTransform->usage2));
 }
 
-void transform_fromhost_VkDeviceBufferMemoryRequirementsKHR(
-    VkDecoderGlobalState* resourceTracker, VkDeviceBufferMemoryRequirementsKHR* toTransform) {
+void transform_fromhost_VkNativeBufferANDROID(VkDecoderGlobalState* resourceTracker,
+                                              VkNativeBufferANDROID* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pCreateInfo) {
-        transform_fromhost_VkBufferCreateInfo(resourceTracker,
-                                              (VkBufferCreateInfo*)(toTransform->pCreateInfo));
-    }
+    transform_fromhost_VkNativeBufferUsage2ANDROID(
+        resourceTracker, (VkNativeBufferUsage2ANDROID*)(&toTransform->usage2));
 }
 
-void transform_tohost_VkDeviceImageMemoryRequirementsKHR(
-    VkDecoderGlobalState* resourceTracker, VkDeviceImageMemoryRequirementsKHR* toTransform) {
+void transform_tohost_VkSwapchainImageCreateInfoANDROID(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainImageCreateInfoANDROID* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pCreateInfo) {
-        resourceTracker->transformImpl_VkImageCreateInfo_tohost(toTransform->pCreateInfo, 1);
-        transform_tohost_VkImageCreateInfo(resourceTracker,
-                                           (VkImageCreateInfo*)(toTransform->pCreateInfo));
-    }
 }
 
-void transform_fromhost_VkDeviceImageMemoryRequirementsKHR(
-    VkDecoderGlobalState* resourceTracker, VkDeviceImageMemoryRequirementsKHR* toTransform) {
+void transform_fromhost_VkSwapchainImageCreateInfoANDROID(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainImageCreateInfoANDROID* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pCreateInfo) {
-        resourceTracker->transformImpl_VkImageCreateInfo_fromhost(toTransform->pCreateInfo, 1);
-        transform_fromhost_VkImageCreateInfo(resourceTracker,
-                                             (VkImageCreateInfo*)(toTransform->pCreateInfo));
-    }
 }
 
-#endif
-#ifdef VK_ANDROID_native_buffer
-void transform_tohost_VkNativeBufferANDROID(VkDecoderGlobalState* resourceTracker,
-                                            VkNativeBufferANDROID* toTransform) {
+void transform_tohost_VkPhysicalDevicePresentationPropertiesANDROID(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePresentationPropertiesANDROID* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -8167,8 +9240,9 @@ void transform_tohost_VkNativeBufferANDROID(VkDecoderGlobalState* resourceTracke
     }
 }
 
-void transform_fromhost_VkNativeBufferANDROID(VkDecoderGlobalState* resourceTracker,
-                                              VkNativeBufferANDROID* toTransform) {
+void transform_fromhost_VkPhysicalDevicePresentationPropertiesANDROID(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePresentationPropertiesANDROID* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -8515,12 +9589,6 @@ void transform_tohost_VkVideoEncodeH264CapabilitiesEXT(
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minPictureSizeInMbs));
-    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxPictureSizeInMbs));
-    transform_tohost_VkExtent2D(resourceTracker,
-                                (VkExtent2D*)(&toTransform->inputImageDataAlignment));
-    transform_tohost_VkExtensionProperties(
-        resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
 }
 
 void transform_fromhost_VkVideoEncodeH264CapabilitiesEXT(
@@ -8530,43 +9598,6 @@ void transform_fromhost_VkVideoEncodeH264CapabilitiesEXT(
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_fromhost_VkExtent2D(resourceTracker,
-                                  (VkExtent2D*)(&toTransform->minPictureSizeInMbs));
-    transform_fromhost_VkExtent2D(resourceTracker,
-                                  (VkExtent2D*)(&toTransform->maxPictureSizeInMbs));
-    transform_fromhost_VkExtent2D(resourceTracker,
-                                  (VkExtent2D*)(&toTransform->inputImageDataAlignment));
-    transform_fromhost_VkExtensionProperties(
-        resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
-}
-
-void transform_tohost_VkVideoEncodeH264SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264SessionCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxPictureSizeInMbs));
-    if (toTransform->pStdExtensionVersion) {
-        transform_tohost_VkExtensionProperties(
-            resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
-    }
-}
-
-void transform_fromhost_VkVideoEncodeH264SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264SessionCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_fromhost_VkExtent2D(resourceTracker,
-                                  (VkExtent2D*)(&toTransform->maxPictureSizeInMbs));
-    if (toTransform->pStdExtensionVersion) {
-        transform_fromhost_VkExtensionProperties(
-            resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
-    }
 }
 
 void transform_tohost_VkVideoEncodeH264SessionParametersAddInfoEXT(
@@ -8619,8 +9650,8 @@ void transform_fromhost_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     }
 }
 
-void transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264DpbSlotInfoEXT* toTransform) {
+void transform_tohost_VkVideoEncodeH264NaluSliceInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264NaluSliceInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -8628,8 +9659,8 @@ void transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
     }
 }
 
-void transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264DpbSlotInfoEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH264NaluSliceInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264NaluSliceInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -8637,146 +9668,62 @@ void transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
     }
 }
 
-void transform_tohost_VkVideoEncodeH264NaluSliceEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoEncodeH264NaluSliceEXT* toTransform) {
+void transform_tohost_VkVideoEncodeH264VclFrameInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264VclFrameInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
     if (toTransform) {
-        if (toTransform->pRefFinalList0Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->refFinalList0EntryCount; ++i) {
-                transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
-                    resourceTracker,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefFinalList0Entries + i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pRefFinalList1Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->refFinalList1EntryCount; ++i) {
-                transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
+        if (toTransform->pNaluSliceEntries) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i) {
+                transform_tohost_VkVideoEncodeH264NaluSliceInfoEXT(
                     resourceTracker,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefFinalList1Entries + i));
+                    (VkVideoEncodeH264NaluSliceInfoEXT*)(toTransform->pNaluSliceEntries + i));
             }
         }
     }
 }
 
-void transform_fromhost_VkVideoEncodeH264NaluSliceEXT(VkDecoderGlobalState* resourceTracker,
-                                                      VkVideoEncodeH264NaluSliceEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH264VclFrameInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264VclFrameInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
     if (toTransform) {
-        if (toTransform->pRefFinalList0Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->refFinalList0EntryCount; ++i) {
-                transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
-                    resourceTracker,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefFinalList0Entries + i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pRefFinalList1Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->refFinalList1EntryCount; ++i) {
-                transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
+        if (toTransform->pNaluSliceEntries) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i) {
+                transform_fromhost_VkVideoEncodeH264NaluSliceInfoEXT(
                     resourceTracker,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefFinalList1Entries + i));
+                    (VkVideoEncodeH264NaluSliceInfoEXT*)(toTransform->pNaluSliceEntries + i));
             }
         }
     }
 }
 
-void transform_tohost_VkVideoEncodeH264VclFrameInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264VclFrameInfoEXT* toTransform) {
+void transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264DpbSlotInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform) {
-        if (toTransform->pRefDefaultFinalList0Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->refDefaultFinalList0EntryCount; ++i) {
-                transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
-                    resourceTracker,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefDefaultFinalList0Entries +
-                                                       i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pRefDefaultFinalList1Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->refDefaultFinalList1EntryCount; ++i) {
-                transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
-                    resourceTracker,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefDefaultFinalList1Entries +
-                                                       i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pNaluSliceEntries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i) {
-                transform_tohost_VkVideoEncodeH264NaluSliceEXT(
-                    resourceTracker,
-                    (VkVideoEncodeH264NaluSliceEXT*)(toTransform->pNaluSliceEntries + i));
-            }
-        }
-    }
-    if (toTransform->pCurrentPictureInfo) {
-        transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
-            resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pCurrentPictureInfo));
-    }
 }
 
-void transform_fromhost_VkVideoEncodeH264VclFrameInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264VclFrameInfoEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264DpbSlotInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform) {
-        if (toTransform->pRefDefaultFinalList0Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->refDefaultFinalList0EntryCount; ++i) {
-                transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
-                    resourceTracker,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefDefaultFinalList0Entries +
-                                                       i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pRefDefaultFinalList1Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->refDefaultFinalList1EntryCount; ++i) {
-                transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
-                    resourceTracker,
-                    (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pRefDefaultFinalList1Entries +
-                                                       i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pNaluSliceEntries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i) {
-                transform_fromhost_VkVideoEncodeH264NaluSliceEXT(
-                    resourceTracker,
-                    (VkVideoEncodeH264NaluSliceEXT*)(toTransform->pNaluSliceEntries + i));
-            }
-        }
-    }
-    if (toTransform->pCurrentPictureInfo) {
-        transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
-            resourceTracker, (VkVideoEncodeH264DpbSlotInfoEXT*)(toTransform->pCurrentPictureInfo));
-    }
 }
 
-void transform_tohost_VkVideoEncodeH264EmitPictureParametersEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264EmitPictureParametersEXT* toTransform) {
+void transform_tohost_VkVideoEncodeH264ProfileInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264ProfileInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -8784,8 +9731,8 @@ void transform_tohost_VkVideoEncodeH264EmitPictureParametersEXT(
     }
 }
 
-void transform_fromhost_VkVideoEncodeH264EmitPictureParametersEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264EmitPictureParametersEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH264ProfileInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264ProfileInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -8793,8 +9740,8 @@ void transform_fromhost_VkVideoEncodeH264EmitPictureParametersEXT(
     }
 }
 
-void transform_tohost_VkVideoEncodeH264ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                  VkVideoEncodeH264ProfileEXT* toTransform) {
+void transform_tohost_VkVideoEncodeH264RateControlInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264RateControlInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -8802,8 +9749,8 @@ void transform_tohost_VkVideoEncodeH264ProfileEXT(VkDecoderGlobalState* resource
     }
 }
 
-void transform_fromhost_VkVideoEncodeH264ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoEncodeH264ProfileEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH264RateControlInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264RateControlInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -8811,58 +9758,82 @@ void transform_fromhost_VkVideoEncodeH264ProfileEXT(VkDecoderGlobalState* resour
     }
 }
 
-#endif
-#ifdef VK_EXT_video_encode_h265
-void transform_tohost_VkVideoEncodeH265CapabilitiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265CapabilitiesEXT* toTransform) {
+void transform_tohost_VkVideoEncodeH264QpEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkVideoEncodeH264QpEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkVideoEncodeH264QpEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkVideoEncodeH264QpEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_tohost_VkVideoEncodeH264FrameSizeEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkVideoEncodeH264FrameSizeEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkVideoEncodeH264FrameSizeEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoEncodeH264FrameSizeEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_tohost_VkVideoEncodeH264RateControlLayerInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264RateControlLayerInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_tohost_VkExtent2D(resourceTracker,
-                                (VkExtent2D*)(&toTransform->inputImageDataAlignment));
-    transform_tohost_VkExtensionProperties(
-        resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
+    transform_tohost_VkVideoEncodeH264QpEXT(resourceTracker,
+                                            (VkVideoEncodeH264QpEXT*)(&toTransform->initialRcQp));
+    transform_tohost_VkVideoEncodeH264QpEXT(resourceTracker,
+                                            (VkVideoEncodeH264QpEXT*)(&toTransform->minQp));
+    transform_tohost_VkVideoEncodeH264QpEXT(resourceTracker,
+                                            (VkVideoEncodeH264QpEXT*)(&toTransform->maxQp));
+    transform_tohost_VkVideoEncodeH264FrameSizeEXT(
+        resourceTracker, (VkVideoEncodeH264FrameSizeEXT*)(&toTransform->maxFrameSize));
 }
 
-void transform_fromhost_VkVideoEncodeH265CapabilitiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265CapabilitiesEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH264RateControlLayerInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264RateControlLayerInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    transform_fromhost_VkExtent2D(resourceTracker,
-                                  (VkExtent2D*)(&toTransform->inputImageDataAlignment));
-    transform_fromhost_VkExtensionProperties(
-        resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
+    transform_fromhost_VkVideoEncodeH264QpEXT(resourceTracker,
+                                              (VkVideoEncodeH264QpEXT*)(&toTransform->initialRcQp));
+    transform_fromhost_VkVideoEncodeH264QpEXT(resourceTracker,
+                                              (VkVideoEncodeH264QpEXT*)(&toTransform->minQp));
+    transform_fromhost_VkVideoEncodeH264QpEXT(resourceTracker,
+                                              (VkVideoEncodeH264QpEXT*)(&toTransform->maxQp));
+    transform_fromhost_VkVideoEncodeH264FrameSizeEXT(
+        resourceTracker, (VkVideoEncodeH264FrameSizeEXT*)(&toTransform->maxFrameSize));
 }
 
-void transform_tohost_VkVideoEncodeH265SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265SessionCreateInfoEXT* toTransform) {
+#endif
+#ifdef VK_EXT_video_encode_h265
+void transform_tohost_VkVideoEncodeH265CapabilitiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265CapabilitiesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pStdExtensionVersion) {
-        transform_tohost_VkExtensionProperties(
-            resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
-    }
 }
 
-void transform_fromhost_VkVideoEncodeH265SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265SessionCreateInfoEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH265CapabilitiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265CapabilitiesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pStdExtensionVersion) {
-        transform_fromhost_VkExtensionProperties(
-            resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
-    }
 }
 
 void transform_tohost_VkVideoEncodeH265SessionParametersAddInfoEXT(
@@ -8915,8 +9886,8 @@ void transform_fromhost_VkVideoEncodeH265SessionParametersCreateInfoEXT(
     }
 }
 
-void transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265DpbSlotInfoEXT* toTransform) {
+void transform_tohost_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265NaluSliceSegmentInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -8924,8 +9895,8 @@ void transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(
     }
 }
 
-void transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265DpbSlotInfoEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265NaluSliceSegmentInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -8933,88 +9904,6 @@ void transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(
     }
 }
 
-void transform_tohost_VkVideoEncodeH265ReferenceListsEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265ReferenceListsEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pReferenceList0Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->referenceList0EntryCount; ++i) {
-                transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(
-                    resourceTracker,
-                    (VkVideoEncodeH265DpbSlotInfoEXT*)(toTransform->pReferenceList0Entries + i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pReferenceList1Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->referenceList1EntryCount; ++i) {
-                transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(
-                    resourceTracker,
-                    (VkVideoEncodeH265DpbSlotInfoEXT*)(toTransform->pReferenceList1Entries + i));
-            }
-        }
-    }
-}
-
-void transform_fromhost_VkVideoEncodeH265ReferenceListsEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265ReferenceListsEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform) {
-        if (toTransform->pReferenceList0Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->referenceList0EntryCount; ++i) {
-                transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(
-                    resourceTracker,
-                    (VkVideoEncodeH265DpbSlotInfoEXT*)(toTransform->pReferenceList0Entries + i));
-            }
-        }
-    }
-    if (toTransform) {
-        if (toTransform->pReferenceList1Entries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->referenceList1EntryCount; ++i) {
-                transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(
-                    resourceTracker,
-                    (VkVideoEncodeH265DpbSlotInfoEXT*)(toTransform->pReferenceList1Entries + i));
-            }
-        }
-    }
-}
-
-void transform_tohost_VkVideoEncodeH265NaluSliceEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoEncodeH265NaluSliceEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform->pReferenceFinalLists) {
-        transform_tohost_VkVideoEncodeH265ReferenceListsEXT(
-            resourceTracker,
-            (VkVideoEncodeH265ReferenceListsEXT*)(toTransform->pReferenceFinalLists));
-    }
-}
-
-void transform_fromhost_VkVideoEncodeH265NaluSliceEXT(VkDecoderGlobalState* resourceTracker,
-                                                      VkVideoEncodeH265NaluSliceEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform->pReferenceFinalLists) {
-        transform_fromhost_VkVideoEncodeH265ReferenceListsEXT(
-            resourceTracker,
-            (VkVideoEncodeH265ReferenceListsEXT*)(toTransform->pReferenceFinalLists));
-    }
-}
-
 void transform_tohost_VkVideoEncodeH265VclFrameInfoEXT(
     VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265VclFrameInfoEXT* toTransform) {
     (void)resourceTracker;
@@ -9022,17 +9911,14 @@ void transform_tohost_VkVideoEncodeH265VclFrameInfoEXT(
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pReferenceFinalLists) {
-        transform_tohost_VkVideoEncodeH265ReferenceListsEXT(
-            resourceTracker,
-            (VkVideoEncodeH265ReferenceListsEXT*)(toTransform->pReferenceFinalLists));
-    }
     if (toTransform) {
-        if (toTransform->pNaluSliceEntries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i) {
-                transform_tohost_VkVideoEncodeH265NaluSliceEXT(
+        if (toTransform->pNaluSliceSegmentEntries) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceSegmentEntryCount; ++i) {
+                transform_tohost_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
                     resourceTracker,
-                    (VkVideoEncodeH265NaluSliceEXT*)(toTransform->pNaluSliceEntries + i));
+                    (VkVideoEncodeH265NaluSliceSegmentInfoEXT*)(toTransform
+                                                                    ->pNaluSliceSegmentEntries +
+                                                                i));
             }
         }
     }
@@ -9045,133 +9931,39 @@ void transform_fromhost_VkVideoEncodeH265VclFrameInfoEXT(
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pReferenceFinalLists) {
-        transform_fromhost_VkVideoEncodeH265ReferenceListsEXT(
-            resourceTracker,
-            (VkVideoEncodeH265ReferenceListsEXT*)(toTransform->pReferenceFinalLists));
-    }
     if (toTransform) {
-        if (toTransform->pNaluSliceEntries) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceEntryCount; ++i) {
-                transform_fromhost_VkVideoEncodeH265NaluSliceEXT(
+        if (toTransform->pNaluSliceSegmentEntries) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->naluSliceSegmentEntryCount; ++i) {
+                transform_fromhost_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
                     resourceTracker,
-                    (VkVideoEncodeH265NaluSliceEXT*)(toTransform->pNaluSliceEntries + i));
+                    (VkVideoEncodeH265NaluSliceSegmentInfoEXT*)(toTransform
+                                                                    ->pNaluSliceSegmentEntries +
+                                                                i));
             }
         }
     }
 }
 
-void transform_tohost_VkVideoEncodeH265EmitPictureParametersEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265EmitPictureParametersEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkVideoEncodeH265EmitPictureParametersEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265EmitPictureParametersEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_tohost_VkVideoEncodeH265ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                  VkVideoEncodeH265ProfileEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkVideoEncodeH265ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoEncodeH265ProfileEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-#endif
-#ifdef VK_EXT_video_decode_h264
-void transform_tohost_VkVideoDecodeH264ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                  VkVideoDecodeH264ProfileEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkVideoDecodeH264ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoDecodeH264ProfileEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_tohost_VkVideoDecodeH264CapabilitiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264CapabilitiesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_tohost_VkOffset2D(resourceTracker,
-                                (VkOffset2D*)(&toTransform->fieldOffsetGranularity));
-    transform_tohost_VkExtensionProperties(
-        resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
-}
-
-void transform_fromhost_VkVideoDecodeH264CapabilitiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264CapabilitiesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_fromhost_VkOffset2D(resourceTracker,
-                                  (VkOffset2D*)(&toTransform->fieldOffsetGranularity));
-    transform_fromhost_VkExtensionProperties(
-        resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
-}
-
-void transform_tohost_VkVideoDecodeH264SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264SessionCreateInfoEXT* toTransform) {
+void transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265DpbSlotInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pStdExtensionVersion) {
-        transform_tohost_VkExtensionProperties(
-            resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
-    }
 }
 
-void transform_fromhost_VkVideoDecodeH264SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264SessionCreateInfoEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265DpbSlotInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pStdExtensionVersion) {
-        transform_fromhost_VkExtensionProperties(
-            resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
-    }
 }
 
-void transform_tohost_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH264SessionParametersAddInfoEXT* toTransform) {
+void transform_tohost_VkVideoEncodeH265ProfileInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265ProfileInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -9179,9 +9971,8 @@ void transform_tohost_VkVideoDecodeH264SessionParametersAddInfoEXT(
     }
 }
 
-void transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH264SessionParametersAddInfoEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH265ProfileInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265ProfileInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -9189,88 +9980,80 @@ void transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoEXT(
     }
 }
 
-void transform_tohost_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH264SessionParametersCreateInfoEXT* toTransform) {
+void transform_tohost_VkVideoEncodeH265RateControlInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265RateControlInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pParametersAddInfo) {
-        transform_tohost_VkVideoDecodeH264SessionParametersAddInfoEXT(
-            resourceTracker,
-            (VkVideoDecodeH264SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
-    }
 }
 
-void transform_fromhost_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH264SessionParametersCreateInfoEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH265RateControlInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265RateControlInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
-    if (toTransform->pParametersAddInfo) {
-        transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoEXT(
-            resourceTracker,
-            (VkVideoDecodeH264SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
-    }
 }
 
-void transform_tohost_VkVideoDecodeH264PictureInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264PictureInfoEXT* toTransform) {
+void transform_tohost_VkVideoEncodeH265QpEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkVideoEncodeH265QpEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
 }
 
-void transform_fromhost_VkVideoDecodeH264PictureInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264PictureInfoEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH265QpEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkVideoEncodeH265QpEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
 }
 
-void transform_tohost_VkVideoDecodeH264MvcEXT(VkDecoderGlobalState* resourceTracker,
-                                              VkVideoDecodeH264MvcEXT* toTransform) {
+void transform_tohost_VkVideoEncodeH265FrameSizeEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkVideoEncodeH265FrameSizeEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
 }
 
-void transform_fromhost_VkVideoDecodeH264MvcEXT(VkDecoderGlobalState* resourceTracker,
-                                                VkVideoDecodeH264MvcEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH265FrameSizeEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoEncodeH265FrameSizeEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
 }
 
-void transform_tohost_VkVideoDecodeH264DpbSlotInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264DpbSlotInfoEXT* toTransform) {
+void transform_tohost_VkVideoEncodeH265RateControlLayerInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265RateControlLayerInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
+    transform_tohost_VkVideoEncodeH265QpEXT(resourceTracker,
+                                            (VkVideoEncodeH265QpEXT*)(&toTransform->initialRcQp));
+    transform_tohost_VkVideoEncodeH265QpEXT(resourceTracker,
+                                            (VkVideoEncodeH265QpEXT*)(&toTransform->minQp));
+    transform_tohost_VkVideoEncodeH265QpEXT(resourceTracker,
+                                            (VkVideoEncodeH265QpEXT*)(&toTransform->maxQp));
+    transform_tohost_VkVideoEncodeH265FrameSizeEXT(
+        resourceTracker, (VkVideoEncodeH265FrameSizeEXT*)(&toTransform->maxFrameSize));
 }
 
-void transform_fromhost_VkVideoDecodeH264DpbSlotInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264DpbSlotInfoEXT* toTransform) {
+void transform_fromhost_VkVideoEncodeH265RateControlLayerInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265RateControlLayerInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
         transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
     }
+    transform_fromhost_VkVideoEncodeH265QpEXT(resourceTracker,
+                                              (VkVideoEncodeH265QpEXT*)(&toTransform->initialRcQp));
+    transform_fromhost_VkVideoEncodeH265QpEXT(resourceTracker,
+                                              (VkVideoEncodeH265QpEXT*)(&toTransform->minQp));
+    transform_fromhost_VkVideoEncodeH265QpEXT(resourceTracker,
+                                              (VkVideoEncodeH265QpEXT*)(&toTransform->maxQp));
+    transform_fromhost_VkVideoEncodeH265FrameSizeEXT(
+        resourceTracker, (VkVideoEncodeH265FrameSizeEXT*)(&toTransform->maxFrameSize));
 }
 
 #endif
@@ -9469,6 +10252,10 @@ void transform_tohost_VkWin32KeyedMutexAcquireReleaseInfoNV(
     VkDecoderGlobalState* resourceTracker, VkWin32KeyedMutexAcquireReleaseInfoNV* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
+    resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)toTransform->pAcquireSyncs,
+                                                  toTransform->acquireCount, (VkDeviceSize*)nullptr,
+                                                  0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr,
+                                                  0, (uint32_t*)nullptr, 0);
     resourceTracker->deviceMemoryTransform_tohost((VkDeviceMemory*)toTransform->pReleaseSyncs,
                                                   toTransform->releaseCount, (VkDeviceSize*)nullptr,
                                                   0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr,
@@ -9483,6 +10270,10 @@ void transform_fromhost_VkWin32KeyedMutexAcquireReleaseInfoNV(
     (void)resourceTracker;
     (void)toTransform;
     resourceTracker->deviceMemoryTransform_fromhost(
+        (VkDeviceMemory*)toTransform->pAcquireSyncs, toTransform->acquireCount,
+        (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0,
+        (uint32_t*)nullptr, 0);
+    resourceTracker->deviceMemoryTransform_fromhost(
         (VkDeviceMemory*)toTransform->pReleaseSyncs, toTransform->releaseCount,
         (VkDeviceSize*)nullptr, 0, (VkDeviceSize*)nullptr, 0, (uint32_t*)nullptr, 0,
         (uint32_t*)nullptr, 0);
@@ -9537,9 +10328,49 @@ void transform_fromhost_VkViSurfaceCreateInfoNN(VkDecoderGlobalState* resourceTr
 #ifdef VK_EXT_shader_subgroup_vote
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
-void transform_tohost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
+#endif
+#ifdef VK_EXT_astc_decode_mode
+void transform_tohost_VkImageViewASTCDecodeModeEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkImageViewASTCDecodeModeEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkImageViewASTCDecodeModeEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkImageViewASTCDecodeModeEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceASTCDecodeFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceASTCDecodeFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceASTCDecodeFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_pipeline_robustness
+void transform_tohost_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toTransform) {
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -9547,9 +10378,9 @@ void transform_tohost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
     }
 }
 
-void transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
+void transform_fromhost_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toTransform) {
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -9557,10 +10388,9 @@ void transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
     }
 }
 
-#endif
-#ifdef VK_EXT_astc_decode_mode
-void transform_tohost_VkImageViewASTCDecodeModeEXT(VkDecoderGlobalState* resourceTracker,
-                                                   VkImageViewASTCDecodeModeEXT* toTransform) {
+void transform_tohost_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -9568,8 +10398,9 @@ void transform_tohost_VkImageViewASTCDecodeModeEXT(VkDecoderGlobalState* resourc
     }
 }
 
-void transform_fromhost_VkImageViewASTCDecodeModeEXT(VkDecoderGlobalState* resourceTracker,
-                                                     VkImageViewASTCDecodeModeEXT* toTransform) {
+void transform_fromhost_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -9577,8 +10408,8 @@ void transform_fromhost_VkImageViewASTCDecodeModeEXT(VkDecoderGlobalState* resou
     }
 }
 
-void transform_tohost_VkPhysicalDeviceASTCDecodeFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceASTCDecodeFeaturesEXT* toTransform) {
+void transform_tohost_VkPipelineRobustnessCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkPipelineRobustnessCreateInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -9586,8 +10417,8 @@ void transform_tohost_VkPhysicalDeviceASTCDecodeFeaturesEXT(
     }
 }
 
-void transform_fromhost_VkPhysicalDeviceASTCDecodeFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceASTCDecodeFeaturesEXT* toTransform) {
+void transform_fromhost_VkPipelineRobustnessCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkPipelineRobustnessCreateInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -10190,8 +11021,6 @@ void transform_fromhost_VkMacOSSurfaceCreateInfoMVK(VkDecoderGlobalState* resour
 }
 
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -10499,84 +11328,6 @@ void transform_fromhost_VkAndroidHardwareBufferFormatProperties2ANDROID(
 #ifdef VK_AMD_shader_fragment_mask
 #endif
 #ifdef VK_EXT_inline_uniform_block
-void transform_tohost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_tohost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_tohost_VkWriteDescriptorSetInlineUniformBlockEXT(
-    VkDecoderGlobalState* resourceTracker, VkWriteDescriptorSetInlineUniformBlockEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkWriteDescriptorSetInlineUniformBlockEXT(
-    VkDecoderGlobalState* resourceTracker, VkWriteDescriptorSetInlineUniformBlockEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_tohost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
 #endif
 #ifdef VK_EXT_shader_stencil_export
 #endif
@@ -11771,24 +12522,6 @@ void transform_fromhost_VkFilterCubicImageViewImageFormatPropertiesEXT(
 #ifdef VK_QCOM_render_pass_shader_resolve
 #endif
 #ifdef VK_EXT_global_priority
-void transform_tohost_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
 #endif
 #ifdef VK_EXT_external_memory_host
 void transform_tohost_VkImportMemoryHostPointerInfoEXT(
@@ -11916,160 +12649,6 @@ void transform_fromhost_VkPhysicalDeviceShaderCorePropertiesAMD(
 }
 
 #endif
-#ifdef VK_EXT_video_decode_h265
-void transform_tohost_VkVideoDecodeH265ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                  VkVideoDecodeH265ProfileEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkVideoDecodeH265ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoDecodeH265ProfileEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_tohost_VkVideoDecodeH265CapabilitiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265CapabilitiesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_tohost_VkExtensionProperties(
-        resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
-}
-
-void transform_fromhost_VkVideoDecodeH265CapabilitiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265CapabilitiesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    transform_fromhost_VkExtensionProperties(
-        resourceTracker, (VkExtensionProperties*)(&toTransform->stdExtensionVersion));
-}
-
-void transform_tohost_VkVideoDecodeH265SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265SessionCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform->pStdExtensionVersion) {
-        transform_tohost_VkExtensionProperties(
-            resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
-    }
-}
-
-void transform_fromhost_VkVideoDecodeH265SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265SessionCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform->pStdExtensionVersion) {
-        transform_fromhost_VkExtensionProperties(
-            resourceTracker, (VkExtensionProperties*)(toTransform->pStdExtensionVersion));
-    }
-}
-
-void transform_tohost_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH265SessionParametersAddInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH265SessionParametersAddInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_tohost_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH265SessionParametersCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform->pParametersAddInfo) {
-        transform_tohost_VkVideoDecodeH265SessionParametersAddInfoEXT(
-            resourceTracker,
-            (VkVideoDecodeH265SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
-    }
-}
-
-void transform_fromhost_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH265SessionParametersCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform->pParametersAddInfo) {
-        transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoEXT(
-            resourceTracker,
-            (VkVideoDecodeH265SessionParametersAddInfoEXT*)(toTransform->pParametersAddInfo));
-    }
-}
-
-void transform_tohost_VkVideoDecodeH265PictureInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265PictureInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkVideoDecodeH265PictureInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265PictureInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_tohost_VkVideoDecodeH265DpbSlotInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265DpbSlotInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkVideoDecodeH265DpbSlotInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265DpbSlotInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 void transform_tohost_VkDeviceMemoryOverallocationCreateInfoAMD(
     VkDecoderGlobalState* resourceTracker, VkDeviceMemoryOverallocationCreateInfoAMD* toTransform) {
@@ -12207,68 +12786,6 @@ void transform_fromhost_VkPresentFrameTokenGGP(VkDecoderGlobalState* resourceTra
 
 #endif
 #ifdef VK_EXT_pipeline_creation_feedback
-void transform_tohost_VkPipelineCreationFeedbackEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkPipelineCreationFeedbackEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-}
-
-void transform_fromhost_VkPipelineCreationFeedbackEXT(VkDecoderGlobalState* resourceTracker,
-                                                      VkPipelineCreationFeedbackEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-}
-
-void transform_tohost_VkPipelineCreationFeedbackCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkPipelineCreationFeedbackCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform->pPipelineCreationFeedback) {
-        transform_tohost_VkPipelineCreationFeedbackEXT(
-            resourceTracker,
-            (VkPipelineCreationFeedbackEXT*)(toTransform->pPipelineCreationFeedback));
-    }
-    if (toTransform) {
-        if (toTransform->pPipelineStageCreationFeedbacks) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->pipelineStageCreationFeedbackCount;
-                 ++i) {
-                transform_tohost_VkPipelineCreationFeedbackEXT(
-                    resourceTracker,
-                    (VkPipelineCreationFeedbackEXT*)(toTransform->pPipelineStageCreationFeedbacks +
-                                                     i));
-            }
-        }
-    }
-}
-
-void transform_fromhost_VkPipelineCreationFeedbackCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkPipelineCreationFeedbackCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-    if (toTransform->pPipelineCreationFeedback) {
-        transform_fromhost_VkPipelineCreationFeedbackEXT(
-            resourceTracker,
-            (VkPipelineCreationFeedbackEXT*)(toTransform->pPipelineCreationFeedback));
-    }
-    if (toTransform) {
-        if (toTransform->pPipelineStageCreationFeedbacks) {
-            for (uint32_t i = 0; i < (uint32_t)toTransform->pipelineStageCreationFeedbackCount;
-                 ++i) {
-                transform_fromhost_VkPipelineCreationFeedbackEXT(
-                    resourceTracker,
-                    (VkPipelineCreationFeedbackEXT*)(toTransform->pPipelineStageCreationFeedbacks +
-                                                     i));
-            }
-        }
-    }
-}
-
 #endif
 #ifdef VK_NV_shader_subgroup_partitioned
 #endif
@@ -12345,26 +12862,6 @@ void transform_fromhost_VkDrawMeshTasksIndirectCommandNV(
 
 #endif
 #ifdef VK_NV_fragment_shader_barycentric
-void transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
 #endif
 #ifdef VK_NV_shader_image_footprint
 void transform_tohost_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -12827,66 +13324,6 @@ void transform_fromhost_VkRenderPassFragmentDensityMapCreateInfoEXT(
 #ifdef VK_GOOGLE_decorate_string
 #endif
 #ifdef VK_EXT_subgroup_size_control
-void transform_tohost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_tohost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_tohost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
 #endif
 #ifdef VK_AMD_shader_core_properties2
 void transform_tohost_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -13071,24 +13508,6 @@ void transform_fromhost_VkBufferDeviceAddressCreateInfoEXT(
 
 #endif
 #ifdef VK_EXT_tooling_info
-void transform_tohost_VkPhysicalDeviceToolPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceToolPropertiesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkPhysicalDeviceToolPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceToolPropertiesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
 #endif
 #ifdef VK_EXT_separate_stencil_usage
 #endif
@@ -13566,10 +13985,72 @@ void transform_fromhost_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
 }
 
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-void transform_tohost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+void transform_tohost_VkSurfacePresentModeEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkSurfacePresentModeEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkSurfacePresentModeEXT(VkDecoderGlobalState* resourceTracker,
+                                                VkSurfacePresentModeEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkSurfacePresentScalingCapabilitiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkSurfacePresentScalingCapabilitiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->minScaledImageExtent));
+    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxScaledImageExtent));
+}
+
+void transform_fromhost_VkSurfacePresentScalingCapabilitiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkSurfacePresentScalingCapabilitiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkExtent2D(resourceTracker,
+                                  (VkExtent2D*)(&toTransform->minScaledImageExtent));
+    transform_fromhost_VkExtent2D(resourceTracker,
+                                  (VkExtent2D*)(&toTransform->maxScaledImageExtent));
+}
+
+void transform_tohost_VkSurfacePresentModeCompatibilityEXT(
+    VkDecoderGlobalState* resourceTracker, VkSurfacePresentModeCompatibilityEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkSurfacePresentModeCompatibilityEXT(
+    VkDecoderGlobalState* resourceTracker, VkSurfacePresentModeCompatibilityEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+void transform_tohost_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toTransform) {
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -13577,9 +14058,99 @@ void transform_tohost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
     }
 }
 
-void transform_fromhost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+void transform_fromhost_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toTransform) {
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkSwapchainPresentFenceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkSwapchainPresentFenceInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkSwapchainPresentFenceInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainPresentFenceInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkSwapchainPresentModesCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainPresentModesCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkSwapchainPresentModesCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainPresentModesCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkSwapchainPresentModeInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkSwapchainPresentModeInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkSwapchainPresentModeInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkSwapchainPresentModeInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkSwapchainPresentScalingCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainPresentScalingCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkSwapchainPresentScalingCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainPresentScalingCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkReleaseSwapchainImagesInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkReleaseSwapchainImagesInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkReleaseSwapchainImagesInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkReleaseSwapchainImagesInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -13588,6 +14159,8 @@ void transform_fromhost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEX
 }
 
 #endif
+#ifdef VK_EXT_shader_demote_to_helper_invocation
+#endif
 #ifdef VK_NV_device_generated_commands
 void transform_tohost_VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV(
     VkDecoderGlobalState* resourceTracker,
@@ -13957,26 +14530,6 @@ void transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
     }
 }
 
-void transform_tohost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
-void transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toTransform) {
-    (void)resourceTracker;
-    (void)toTransform;
-    if (toTransform->pNext) {
-        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
-    }
-}
-
 #endif
 #ifdef VK_QCOM_render_pass_transform
 void transform_tohost_VkRenderPassTransformBeginInfoQCOM(
@@ -14184,9 +14737,9 @@ void transform_fromhost_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
-#ifdef VK_EXT_private_data
-void transform_tohost_VkPhysicalDevicePrivateDataFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDevicePrivateDataFeaturesEXT* toTransform) {
+#ifdef VK_NV_present_barrier
+void transform_tohost_VkPhysicalDevicePresentBarrierFeaturesNV(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDevicePresentBarrierFeaturesNV* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14194,8 +14747,8 @@ void transform_tohost_VkPhysicalDevicePrivateDataFeaturesEXT(
     }
 }
 
-void transform_fromhost_VkPhysicalDevicePrivateDataFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDevicePrivateDataFeaturesEXT* toTransform) {
+void transform_fromhost_VkPhysicalDevicePresentBarrierFeaturesNV(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDevicePresentBarrierFeaturesNV* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14203,8 +14756,8 @@ void transform_fromhost_VkPhysicalDevicePrivateDataFeaturesEXT(
     }
 }
 
-void transform_tohost_VkDevicePrivateDataCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkDevicePrivateDataCreateInfoEXT* toTransform) {
+void transform_tohost_VkSurfaceCapabilitiesPresentBarrierNV(
+    VkDecoderGlobalState* resourceTracker, VkSurfaceCapabilitiesPresentBarrierNV* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14212,8 +14765,8 @@ void transform_tohost_VkDevicePrivateDataCreateInfoEXT(
     }
 }
 
-void transform_fromhost_VkDevicePrivateDataCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkDevicePrivateDataCreateInfoEXT* toTransform) {
+void transform_fromhost_VkSurfaceCapabilitiesPresentBarrierNV(
+    VkDecoderGlobalState* resourceTracker, VkSurfaceCapabilitiesPresentBarrierNV* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14221,8 +14774,8 @@ void transform_fromhost_VkDevicePrivateDataCreateInfoEXT(
     }
 }
 
-void transform_tohost_VkPrivateDataSlotCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
-                                                     VkPrivateDataSlotCreateInfoEXT* toTransform) {
+void transform_tohost_VkSwapchainPresentBarrierCreateInfoNV(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainPresentBarrierCreateInfoNV* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14230,8 +14783,8 @@ void transform_tohost_VkPrivateDataSlotCreateInfoEXT(VkDecoderGlobalState* resou
     }
 }
 
-void transform_fromhost_VkPrivateDataSlotCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkPrivateDataSlotCreateInfoEXT* toTransform) {
+void transform_fromhost_VkSwapchainPresentBarrierCreateInfoNV(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainPresentBarrierCreateInfoNV* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14240,10 +14793,14 @@ void transform_fromhost_VkPrivateDataSlotCreateInfoEXT(
 }
 
 #endif
+#ifdef VK_EXT_private_data
+#endif
 #ifdef VK_EXT_pipeline_creation_cache_control
-void transform_tohost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+#endif
+#ifdef VK_NV_device_diagnostics_config
+void transform_tohost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toTransform) {
+    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14251,9 +14808,27 @@ void transform_tohost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
     }
 }
 
-void transform_fromhost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+void transform_fromhost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toTransform) {
+    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDeviceDiagnosticsConfigCreateInfoNV(
+    VkDecoderGlobalState* resourceTracker, VkDeviceDiagnosticsConfigCreateInfoNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkDeviceDiagnosticsConfigCreateInfoNV(
+    VkDecoderGlobalState* resourceTracker, VkDeviceDiagnosticsConfigCreateInfoNV* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14262,10 +14837,250 @@ void transform_fromhost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
 }
 
 #endif
-#ifdef VK_NV_device_diagnostics_config
-void transform_tohost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+#ifdef VK_QCOM_render_pass_store_ops
+#endif
+#ifdef VK_NV_low_latency
+void transform_tohost_VkQueryLowLatencySupportNV(VkDecoderGlobalState* resourceTracker,
+                                                 VkQueryLowLatencySupportNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkQueryLowLatencySupportNV(VkDecoderGlobalState* resourceTracker,
+                                                   VkQueryLowLatencySupportNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_metal_objects
+void transform_tohost_VkExportMetalObjectCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkExportMetalObjectCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkExportMetalObjectCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkExportMetalObjectCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkExportMetalObjectsInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkExportMetalObjectsInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkExportMetalObjectsInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkExportMetalObjectsInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkExportMetalDeviceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkExportMetalDeviceInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkExportMetalDeviceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkExportMetalDeviceInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkExportMetalCommandQueueInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkExportMetalCommandQueueInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkExportMetalCommandQueueInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkExportMetalCommandQueueInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkExportMetalBufferInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkExportMetalBufferInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkExportMetalBufferInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkExportMetalBufferInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkImportMetalBufferInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkImportMetalBufferInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkImportMetalBufferInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkImportMetalBufferInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkExportMetalTextureInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkExportMetalTextureInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkExportMetalTextureInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkExportMetalTextureInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkImportMetalTextureInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkImportMetalTextureInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkImportMetalTextureInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkImportMetalTextureInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkExportMetalIOSurfaceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkExportMetalIOSurfaceInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkExportMetalIOSurfaceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkExportMetalIOSurfaceInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkImportMetalIOSurfaceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkImportMetalIOSurfaceInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkImportMetalIOSurfaceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkImportMetalIOSurfaceInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkExportMetalSharedEventInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkExportMetalSharedEventInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkExportMetalSharedEventInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkExportMetalSharedEventInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkImportMetalSharedEventInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkImportMetalSharedEventInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkImportMetalSharedEventInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkImportMetalSharedEventInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void transform_tohost_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toTransform) {
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14273,9 +15088,9 @@ void transform_tohost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
     }
 }
 
-void transform_fromhost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
+void transform_fromhost_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceDiagnosticsConfigFeaturesNV* toTransform) {
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14283,8 +15098,9 @@ void transform_fromhost_VkPhysicalDeviceDiagnosticsConfigFeaturesNV(
     }
 }
 
-void transform_tohost_VkDeviceDiagnosticsConfigCreateInfoNV(
-    VkDecoderGlobalState* resourceTracker, VkDeviceDiagnosticsConfigCreateInfoNV* toTransform) {
+void transform_tohost_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14292,8 +15108,295 @@ void transform_tohost_VkDeviceDiagnosticsConfigCreateInfoNV(
     }
 }
 
-void transform_fromhost_VkDeviceDiagnosticsConfigCreateInfoNV(
-    VkDecoderGlobalState* resourceTracker, VkDeviceDiagnosticsConfigCreateInfoNV* toTransform) {
+void transform_fromhost_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDescriptorAddressInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkDescriptorAddressInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkDescriptorAddressInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkDescriptorAddressInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDescriptorBufferBindingInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkDescriptorBufferBindingInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkDescriptorBufferBindingInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkDescriptorBufferBindingInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDescriptorDataEXT(VkDecoderGlobalState* resourceTracker,
+                                          VkDescriptorDataEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pCombinedImageSampler) {
+        transform_tohost_VkDescriptorImageInfo(
+            resourceTracker, (VkDescriptorImageInfo*)(toTransform->pCombinedImageSampler));
+    }
+    if (toTransform->pInputAttachmentImage) {
+        transform_tohost_VkDescriptorImageInfo(
+            resourceTracker, (VkDescriptorImageInfo*)(toTransform->pInputAttachmentImage));
+    }
+    if (toTransform->pSampledImage) {
+        transform_tohost_VkDescriptorImageInfo(
+            resourceTracker, (VkDescriptorImageInfo*)(toTransform->pSampledImage));
+    }
+    if (toTransform->pStorageImage) {
+        transform_tohost_VkDescriptorImageInfo(
+            resourceTracker, (VkDescriptorImageInfo*)(toTransform->pStorageImage));
+    }
+    if (toTransform->pUniformTexelBuffer) {
+        transform_tohost_VkDescriptorAddressInfoEXT(
+            resourceTracker, (VkDescriptorAddressInfoEXT*)(toTransform->pUniformTexelBuffer));
+    }
+    if (toTransform->pStorageTexelBuffer) {
+        transform_tohost_VkDescriptorAddressInfoEXT(
+            resourceTracker, (VkDescriptorAddressInfoEXT*)(toTransform->pStorageTexelBuffer));
+    }
+    if (toTransform->pUniformBuffer) {
+        transform_tohost_VkDescriptorAddressInfoEXT(
+            resourceTracker, (VkDescriptorAddressInfoEXT*)(toTransform->pUniformBuffer));
+    }
+    if (toTransform->pStorageBuffer) {
+        transform_tohost_VkDescriptorAddressInfoEXT(
+            resourceTracker, (VkDescriptorAddressInfoEXT*)(toTransform->pStorageBuffer));
+    }
+}
+
+void transform_fromhost_VkDescriptorDataEXT(VkDecoderGlobalState* resourceTracker,
+                                            VkDescriptorDataEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pCombinedImageSampler) {
+        transform_fromhost_VkDescriptorImageInfo(
+            resourceTracker, (VkDescriptorImageInfo*)(toTransform->pCombinedImageSampler));
+    }
+    if (toTransform->pInputAttachmentImage) {
+        transform_fromhost_VkDescriptorImageInfo(
+            resourceTracker, (VkDescriptorImageInfo*)(toTransform->pInputAttachmentImage));
+    }
+    if (toTransform->pSampledImage) {
+        transform_fromhost_VkDescriptorImageInfo(
+            resourceTracker, (VkDescriptorImageInfo*)(toTransform->pSampledImage));
+    }
+    if (toTransform->pStorageImage) {
+        transform_fromhost_VkDescriptorImageInfo(
+            resourceTracker, (VkDescriptorImageInfo*)(toTransform->pStorageImage));
+    }
+    if (toTransform->pUniformTexelBuffer) {
+        transform_fromhost_VkDescriptorAddressInfoEXT(
+            resourceTracker, (VkDescriptorAddressInfoEXT*)(toTransform->pUniformTexelBuffer));
+    }
+    if (toTransform->pStorageTexelBuffer) {
+        transform_fromhost_VkDescriptorAddressInfoEXT(
+            resourceTracker, (VkDescriptorAddressInfoEXT*)(toTransform->pStorageTexelBuffer));
+    }
+    if (toTransform->pUniformBuffer) {
+        transform_fromhost_VkDescriptorAddressInfoEXT(
+            resourceTracker, (VkDescriptorAddressInfoEXT*)(toTransform->pUniformBuffer));
+    }
+    if (toTransform->pStorageBuffer) {
+        transform_fromhost_VkDescriptorAddressInfoEXT(
+            resourceTracker, (VkDescriptorAddressInfoEXT*)(toTransform->pStorageBuffer));
+    }
+}
+
+void transform_tohost_VkDescriptorGetInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkDescriptorGetInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkDescriptorDataEXT(resourceTracker,
+                                         (VkDescriptorDataEXT*)(&toTransform->data));
+}
+
+void transform_fromhost_VkDescriptorGetInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkDescriptorGetInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkDescriptorDataEXT(resourceTracker,
+                                           (VkDescriptorDataEXT*)(&toTransform->data));
+}
+
+void transform_tohost_VkBufferCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkBufferCaptureDescriptorDataInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkBufferCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkBufferCaptureDescriptorDataInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkImageCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkImageCaptureDescriptorDataInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkImageCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkImageCaptureDescriptorDataInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkImageViewCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkImageViewCaptureDescriptorDataInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkImageViewCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkImageViewCaptureDescriptorDataInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkSamplerCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkSamplerCaptureDescriptorDataInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkSamplerCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkSamplerCaptureDescriptorDataInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkOpaqueCaptureDescriptorDataCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkOpaqueCaptureDescriptorDataCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14302,7 +15405,87 @@ void transform_fromhost_VkDeviceDiagnosticsConfigCreateInfoNV(
 }
 
 #endif
-#ifdef VK_QCOM_render_pass_store_ops
+#ifdef VK_EXT_graphics_pipeline_library
+void transform_tohost_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkGraphicsPipelineLibraryCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkGraphicsPipelineLibraryCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkGraphicsPipelineLibraryCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkGraphicsPipelineLibraryCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+void transform_tohost_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
 #endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void transform_tohost_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -14624,9 +15807,113 @@ void transform_fromhost_VkCopyCommandTransformInfoQCOM(
 
 #endif
 #ifdef VK_EXT_image_robustness
-void transform_tohost_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+#endif
+#ifdef VK_EXT_image_compression_control
+void transform_tohost_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkImageCompressionControlEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkImageCompressionControlEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkImageCompressionControlEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkImageCompressionControlEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkSubresourceLayout2EXT(VkDecoderGlobalState* resourceTracker,
+                                              VkSubresourceLayout2EXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkSubresourceLayout(resourceTracker,
+                                         (VkSubresourceLayout*)(&toTransform->subresourceLayout));
+}
+
+void transform_fromhost_VkSubresourceLayout2EXT(VkDecoderGlobalState* resourceTracker,
+                                                VkSubresourceLayout2EXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkSubresourceLayout(resourceTracker,
+                                           (VkSubresourceLayout*)(&toTransform->subresourceLayout));
+}
+
+void transform_tohost_VkImageSubresource2EXT(VkDecoderGlobalState* resourceTracker,
+                                             VkImageSubresource2EXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkImageSubresource(resourceTracker,
+                                        (VkImageSubresource*)(&toTransform->imageSubresource));
+}
+
+void transform_fromhost_VkImageSubresource2EXT(VkDecoderGlobalState* resourceTracker,
+                                               VkImageSubresource2EXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkImageSubresource(resourceTracker,
+                                          (VkImageSubresource*)(&toTransform->imageSubresource));
+}
+
+void transform_tohost_VkImageCompressionPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkImageCompressionPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkImageCompressionPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkImageCompressionPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+void transform_tohost_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceImageRobustnessFeaturesEXT* toTransform) {
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14634,9 +15921,9 @@ void transform_tohost_VkPhysicalDeviceImageRobustnessFeaturesEXT(
     }
 }
 
-void transform_fromhost_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+void transform_fromhost_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceImageRobustnessFeaturesEXT* toTransform) {
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14665,6 +15952,138 @@ void transform_fromhost_VkPhysicalDevice4444FormatsFeaturesEXT(
 }
 
 #endif
+#ifdef VK_EXT_device_fault
+void transform_tohost_VkPhysicalDeviceFaultFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceFaultFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceFaultFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceFaultFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDeviceFaultCountsEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkDeviceFaultCountsEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkDeviceFaultCountsEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkDeviceFaultCountsEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDeviceFaultAddressInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkDeviceFaultAddressInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkDeviceFaultAddressInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkDeviceFaultAddressInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_tohost_VkDeviceFaultVendorInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkDeviceFaultVendorInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkDeviceFaultVendorInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkDeviceFaultVendorInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_tohost_VkDeviceFaultInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                           VkDeviceFaultInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pAddressInfos) {
+        transform_tohost_VkDeviceFaultAddressInfoEXT(
+            resourceTracker, (VkDeviceFaultAddressInfoEXT*)(toTransform->pAddressInfos));
+    }
+    if (toTransform->pVendorInfos) {
+        transform_tohost_VkDeviceFaultVendorInfoEXT(
+            resourceTracker, (VkDeviceFaultVendorInfoEXT*)(toTransform->pVendorInfos));
+    }
+}
+
+void transform_fromhost_VkDeviceFaultInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkDeviceFaultInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pAddressInfos) {
+        transform_fromhost_VkDeviceFaultAddressInfoEXT(
+            resourceTracker, (VkDeviceFaultAddressInfoEXT*)(toTransform->pAddressInfos));
+    }
+    if (toTransform->pVendorInfos) {
+        transform_fromhost_VkDeviceFaultVendorInfoEXT(
+            resourceTracker, (VkDeviceFaultVendorInfoEXT*)(toTransform->pVendorInfos));
+    }
+}
+
+void transform_tohost_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkDeviceFaultVendorBinaryHeaderVersionOneEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkDeviceFaultVendorBinaryHeaderVersionOneEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+void transform_tohost_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 void transform_tohost_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
@@ -14710,9 +16129,9 @@ void transform_fromhost_VkDirectFBSurfaceCreateInfoEXT(
 
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-void transform_tohost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+void transform_tohost_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toTransform) {
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14720,9 +16139,9 @@ void transform_tohost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
     }
 }
 
-void transform_fromhost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+void transform_fromhost_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toTransform) {
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14730,20 +16149,20 @@ void transform_fromhost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
     }
 }
 
-void transform_tohost_VkMutableDescriptorTypeListVALVE(
-    VkDecoderGlobalState* resourceTracker, VkMutableDescriptorTypeListVALVE* toTransform) {
+void transform_tohost_VkMutableDescriptorTypeListEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkMutableDescriptorTypeListEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
 }
 
-void transform_fromhost_VkMutableDescriptorTypeListVALVE(
-    VkDecoderGlobalState* resourceTracker, VkMutableDescriptorTypeListVALVE* toTransform) {
+void transform_fromhost_VkMutableDescriptorTypeListEXT(
+    VkDecoderGlobalState* resourceTracker, VkMutableDescriptorTypeListEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
 }
 
-void transform_tohost_VkMutableDescriptorTypeCreateInfoVALVE(
-    VkDecoderGlobalState* resourceTracker, VkMutableDescriptorTypeCreateInfoVALVE* toTransform) {
+void transform_tohost_VkMutableDescriptorTypeCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkMutableDescriptorTypeCreateInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14752,17 +16171,17 @@ void transform_tohost_VkMutableDescriptorTypeCreateInfoVALVE(
     if (toTransform) {
         if (toTransform->pMutableDescriptorTypeLists) {
             for (uint32_t i = 0; i < (uint32_t)toTransform->mutableDescriptorTypeListCount; ++i) {
-                transform_tohost_VkMutableDescriptorTypeListVALVE(
+                transform_tohost_VkMutableDescriptorTypeListEXT(
                     resourceTracker,
-                    (VkMutableDescriptorTypeListVALVE*)(toTransform->pMutableDescriptorTypeLists +
-                                                        i));
+                    (VkMutableDescriptorTypeListEXT*)(toTransform->pMutableDescriptorTypeLists +
+                                                      i));
             }
         }
     }
 }
 
-void transform_fromhost_VkMutableDescriptorTypeCreateInfoVALVE(
-    VkDecoderGlobalState* resourceTracker, VkMutableDescriptorTypeCreateInfoVALVE* toTransform) {
+void transform_fromhost_VkMutableDescriptorTypeCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkMutableDescriptorTypeCreateInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -14771,10 +16190,10 @@ void transform_fromhost_VkMutableDescriptorTypeCreateInfoVALVE(
     if (toTransform) {
         if (toTransform->pMutableDescriptorTypeLists) {
             for (uint32_t i = 0; i < (uint32_t)toTransform->mutableDescriptorTypeListCount; ++i) {
-                transform_fromhost_VkMutableDescriptorTypeListVALVE(
+                transform_fromhost_VkMutableDescriptorTypeListEXT(
                     resourceTracker,
-                    (VkMutableDescriptorTypeListVALVE*)(toTransform->pMutableDescriptorTypeLists +
-                                                        i));
+                    (VkMutableDescriptorTypeListEXT*)(toTransform->pMutableDescriptorTypeLists +
+                                                      i));
             }
         }
     }
@@ -14859,6 +16278,88 @@ void transform_fromhost_VkPhysicalDeviceDrmPropertiesEXT(
 }
 
 #endif
+#ifdef VK_EXT_device_address_binding_report
+void transform_tohost_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDeviceAddressBindingCallbackDataEXT(
+    VkDecoderGlobalState* resourceTracker, VkDeviceAddressBindingCallbackDataEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkDeviceAddressBindingCallbackDataEXT(
+    VkDecoderGlobalState* resourceTracker, VkDeviceAddressBindingCallbackDataEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_depth_clip_control
+void transform_tohost_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDepthClipControlFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDepthClipControlFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPipelineViewportDepthClipControlCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPipelineViewportDepthClipControlCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 void transform_tohost_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
@@ -15148,9 +16649,13 @@ void transform_tohost_VkImageFormatConstraintsInfoFUCHSIA(
     resourceTracker->transformImpl_VkImageCreateInfo_tohost(&toTransform->imageCreateInfo, 1);
     transform_tohost_VkImageCreateInfo(resourceTracker,
                                        (VkImageCreateInfo*)(&toTransform->imageCreateInfo));
-    if (toTransform->pColorSpaces) {
-        transform_tohost_VkSysmemColorSpaceFUCHSIA(
-            resourceTracker, (VkSysmemColorSpaceFUCHSIA*)(toTransform->pColorSpaces));
+    if (toTransform) {
+        if (toTransform->pColorSpaces) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->colorSpaceCount; ++i) {
+                transform_tohost_VkSysmemColorSpaceFUCHSIA(
+                    resourceTracker, (VkSysmemColorSpaceFUCHSIA*)(toTransform->pColorSpaces + i));
+            }
+        }
     }
 }
 
@@ -15164,9 +16669,13 @@ void transform_fromhost_VkImageFormatConstraintsInfoFUCHSIA(
     resourceTracker->transformImpl_VkImageCreateInfo_fromhost(&toTransform->imageCreateInfo, 1);
     transform_fromhost_VkImageCreateInfo(resourceTracker,
                                          (VkImageCreateInfo*)(&toTransform->imageCreateInfo));
-    if (toTransform->pColorSpaces) {
-        transform_fromhost_VkSysmemColorSpaceFUCHSIA(
-            resourceTracker, (VkSysmemColorSpaceFUCHSIA*)(toTransform->pColorSpaces));
+    if (toTransform) {
+        if (toTransform->pColorSpaces) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->colorSpaceCount; ++i) {
+                transform_fromhost_VkSysmemColorSpaceFUCHSIA(
+                    resourceTracker, (VkSysmemColorSpaceFUCHSIA*)(toTransform->pColorSpaces + i));
+            }
+        }
     }
 }
 
@@ -15335,6 +16844,106 @@ void transform_fromhost_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
 }
 
 #endif
+#ifdef VK_EXT_pipeline_properties
+void transform_tohost_VkPipelinePropertiesIdentifierEXT(
+    VkDecoderGlobalState* resourceTracker, VkPipelinePropertiesIdentifierEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPipelinePropertiesIdentifierEXT(
+    VkDecoderGlobalState* resourceTracker, VkPipelinePropertiesIdentifierEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+void transform_tohost_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkSubpassResolvePerformanceQueryEXT(
+    VkDecoderGlobalState* resourceTracker, VkSubpassResolvePerformanceQueryEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkSubpassResolvePerformanceQueryEXT(
+    VkDecoderGlobalState* resourceTracker, VkSubpassResolvePerformanceQueryEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkMultisampledRenderToSingleSampledInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkMultisampledRenderToSingleSampledInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkMultisampledRenderToSingleSampledInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkMultisampledRenderToSingleSampledInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void transform_tohost_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
@@ -15417,6 +17026,28 @@ void transform_fromhost_VkPipelineColorWriteCreateInfoEXT(
 }
 
 #endif
+#ifdef VK_EXT_primitives_generated_query
+void transform_tohost_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
 #ifdef VK_GOOGLE_gfxstream
 void transform_tohost_VkImportColorBufferGOOGLE(VkDecoderGlobalState* resourceTracker,
                                                 VkImportColorBufferGOOGLE* toTransform) {
@@ -15474,9 +17105,11 @@ void transform_fromhost_VkCreateBlobGOOGLE(VkDecoderGlobalState* resourceTracker
 
 #endif
 #ifdef VK_EXT_global_priority_query
-void transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+#endif
+#ifdef VK_EXT_image_view_min_lod
+void transform_tohost_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toTransform) {
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -15484,9 +17117,9 @@ void transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
     }
 }
 
-void transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
+void transform_fromhost_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toTransform) {
+    VkPhysicalDeviceImageViewMinLodFeaturesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -15494,8 +17127,8 @@ void transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
     }
 }
 
-void transform_tohost_VkQueueFamilyGlobalPriorityPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkQueueFamilyGlobalPriorityPropertiesEXT* toTransform) {
+void transform_tohost_VkImageViewMinLodCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkImageViewMinLodCreateInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -15503,8 +17136,8 @@ void transform_tohost_VkQueueFamilyGlobalPriorityPropertiesEXT(
     }
 }
 
-void transform_fromhost_VkQueueFamilyGlobalPriorityPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkQueueFamilyGlobalPriorityPropertiesEXT* toTransform) {
+void transform_fromhost_VkImageViewMinLodCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkImageViewMinLodCreateInfoEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
     if (toTransform->pNext) {
@@ -15575,8 +17208,492 @@ void transform_fromhost_VkMultiDrawIndexedInfoEXT(VkDecoderGlobalState* resource
 }
 
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+void transform_tohost_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_tile_image
+void transform_tohost_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderTileImageFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderTileImageFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderTileImagePropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderTileImagePropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_opacity_micromap
+void transform_tohost_VkMicromapUsageEXT(VkDecoderGlobalState* resourceTracker,
+                                         VkMicromapUsageEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkMicromapUsageEXT(VkDecoderGlobalState* resourceTracker,
+                                           VkMicromapUsageEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_tohost_VkDeviceOrHostAddressKHR(VkDecoderGlobalState* resourceTracker,
+                                               VkDeviceOrHostAddressKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkDeviceOrHostAddressKHR(VkDecoderGlobalState* resourceTracker,
+                                                 VkDeviceOrHostAddressKHR* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_tohost_VkMicromapBuildInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkMicromapBuildInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pUsageCounts) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->usageCountsCount; ++i) {
+                transform_tohost_VkMicromapUsageEXT(
+                    resourceTracker, (VkMicromapUsageEXT*)(toTransform->pUsageCounts + i));
+            }
+        }
+    }
+    transform_tohost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->data));
+    transform_tohost_VkDeviceOrHostAddressKHR(
+        resourceTracker, (VkDeviceOrHostAddressKHR*)(&toTransform->scratchData));
+    transform_tohost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->triangleArray));
+}
+
+void transform_fromhost_VkMicromapBuildInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkMicromapBuildInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pUsageCounts) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->usageCountsCount; ++i) {
+                transform_fromhost_VkMicromapUsageEXT(
+                    resourceTracker, (VkMicromapUsageEXT*)(toTransform->pUsageCounts + i));
+            }
+        }
+    }
+    transform_fromhost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->data));
+    transform_fromhost_VkDeviceOrHostAddressKHR(
+        resourceTracker, (VkDeviceOrHostAddressKHR*)(&toTransform->scratchData));
+    transform_fromhost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->triangleArray));
+}
+
+void transform_tohost_VkMicromapCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkMicromapCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkMicromapCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                VkMicromapCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceOpacityMicromapFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkMicromapVersionInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkMicromapVersionInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkMicromapVersionInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkMicromapVersionInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkCopyMicromapToMemoryInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkCopyMicromapToMemoryInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkDeviceOrHostAddressKHR(resourceTracker,
+                                              (VkDeviceOrHostAddressKHR*)(&toTransform->dst));
+}
+
+void transform_fromhost_VkCopyMicromapToMemoryInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkCopyMicromapToMemoryInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkDeviceOrHostAddressKHR(resourceTracker,
+                                                (VkDeviceOrHostAddressKHR*)(&toTransform->dst));
+}
+
+void transform_tohost_VkCopyMemoryToMicromapInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkCopyMemoryToMicromapInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->src));
+}
+
+void transform_fromhost_VkCopyMemoryToMicromapInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkCopyMemoryToMicromapInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->src));
+}
+
+void transform_tohost_VkCopyMicromapInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                            VkCopyMicromapInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkCopyMicromapInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkCopyMicromapInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkMicromapBuildSizesInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkMicromapBuildSizesInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkMicromapBuildSizesInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkMicromapBuildSizesInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkAccelerationStructureTrianglesOpacityMicromapEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->indexBuffer));
+    if (toTransform) {
+        if (toTransform->pUsageCounts) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->usageCountsCount; ++i) {
+                transform_tohost_VkMicromapUsageEXT(
+                    resourceTracker, (VkMicromapUsageEXT*)(toTransform->pUsageCounts + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkAccelerationStructureTrianglesOpacityMicromapEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->indexBuffer));
+    if (toTransform) {
+        if (toTransform->pUsageCounts) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->usageCountsCount; ++i) {
+                transform_fromhost_VkMicromapUsageEXT(
+                    resourceTracker, (VkMicromapUsageEXT*)(toTransform->pUsageCounts + i));
+            }
+        }
+    }
+}
+
+void transform_tohost_VkMicromapTriangleEXT(VkDecoderGlobalState* resourceTracker,
+                                            VkMicromapTriangleEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkMicromapTriangleEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkMicromapTriangleEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+#endif
+#ifdef VK_NV_displacement_micromap
+void transform_tohost_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkAccelerationStructureTrianglesDisplacementMicromapNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker,
+        (VkDeviceOrHostAddressConstKHR*)(&toTransform->displacementBiasAndScaleBuffer));
+    transform_tohost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->displacementVectorBuffer));
+    transform_tohost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker,
+        (VkDeviceOrHostAddressConstKHR*)(&toTransform->displacedMicromapPrimitiveFlags));
+    transform_tohost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->indexBuffer));
+    if (toTransform) {
+        if (toTransform->pUsageCounts) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->usageCountsCount; ++i) {
+                transform_tohost_VkMicromapUsageEXT(
+                    resourceTracker, (VkMicromapUsageEXT*)(toTransform->pUsageCounts + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkAccelerationStructureTrianglesDisplacementMicromapNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker,
+        (VkDeviceOrHostAddressConstKHR*)(&toTransform->displacementBiasAndScaleBuffer));
+    transform_fromhost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->displacementVectorBuffer));
+    transform_fromhost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker,
+        (VkDeviceOrHostAddressConstKHR*)(&toTransform->displacedMicromapPrimitiveFlags));
+    transform_fromhost_VkDeviceOrHostAddressConstKHR(
+        resourceTracker, (VkDeviceOrHostAddressConstKHR*)(&toTransform->indexBuffer));
+    if (toTransform) {
+        if (toTransform->pUsageCounts) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->usageCountsCount; ++i) {
+                transform_fromhost_VkMicromapUsageEXT(
+                    resourceTracker, (VkMicromapUsageEXT*)(toTransform->pUsageCounts + i));
+            }
+        }
+    }
+}
+
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void transform_tohost_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
 #ifdef VK_EXT_border_color_swizzle
 void transform_tohost_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
@@ -15645,19 +17762,1383 @@ void transform_fromhost_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
 }
 
 #endif
-#ifdef VK_KHR_acceleration_structure
-void transform_tohost_VkDeviceOrHostAddressKHR(VkDecoderGlobalState* resourceTracker,
-                                               VkDeviceOrHostAddressKHR* toTransform) {
+#ifdef VK_ARM_shader_core_properties
+void transform_tohost_VkPhysicalDeviceShaderCorePropertiesARM(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderCorePropertiesARM* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
 }
 
-void transform_fromhost_VkDeviceOrHostAddressKHR(VkDecoderGlobalState* resourceTracker,
-                                                 VkDeviceOrHostAddressKHR* toTransform) {
+void transform_fromhost_VkPhysicalDeviceShaderCorePropertiesARM(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderCorePropertiesARM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+void transform_tohost_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkImageViewSlicedCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkImageViewSlicedCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkImageViewSlicedCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkImageViewSlicedCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void transform_tohost_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDescriptorSetBindingReferenceVALVE(
+    VkDecoderGlobalState* resourceTracker, VkDescriptorSetBindingReferenceVALVE* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkDescriptorSetBindingReferenceVALVE(
+    VkDecoderGlobalState* resourceTracker, VkDescriptorSetBindingReferenceVALVE* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    VkDecoderGlobalState* resourceTracker, VkDescriptorSetLayoutHostMappingInfoVALVE* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    VkDecoderGlobalState* resourceTracker, VkDescriptorSetLayoutHostMappingInfoVALVE* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+void transform_tohost_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+void transform_tohost_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+void transform_tohost_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkExtent2D(resourceTracker,
+                                (VkExtent2D*)(&toTransform->fragmentDensityOffsetGranularity));
+}
+
+void transform_fromhost_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkExtent2D(resourceTracker,
+                                  (VkExtent2D*)(&toTransform->fragmentDensityOffsetGranularity));
+}
+
+void transform_tohost_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pFragmentDensityOffsets) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->fragmentDensityOffsetCount; ++i) {
+                transform_tohost_VkOffset2D(
+                    resourceTracker, (VkOffset2D*)(toTransform->pFragmentDensityOffsets + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pFragmentDensityOffsets) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->fragmentDensityOffsetCount; ++i) {
+                transform_fromhost_VkOffset2D(
+                    resourceTracker, (VkOffset2D*)(toTransform->pFragmentDensityOffsets + i));
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void transform_tohost_VkCopyMemoryIndirectCommandNV(VkDecoderGlobalState* resourceTracker,
+                                                    VkCopyMemoryIndirectCommandNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkCopyMemoryIndirectCommandNV(VkDecoderGlobalState* resourceTracker,
+                                                      VkCopyMemoryIndirectCommandNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_tohost_VkCopyMemoryToImageIndirectCommandNV(
+    VkDecoderGlobalState* resourceTracker, VkCopyMemoryToImageIndirectCommandNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    transform_tohost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+    transform_tohost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
+    transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
+}
+
+void transform_fromhost_VkCopyMemoryToImageIndirectCommandNV(
+    VkDecoderGlobalState* resourceTracker, VkCopyMemoryToImageIndirectCommandNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    transform_fromhost_VkImageSubresourceLayers(
+        resourceTracker, (VkImageSubresourceLayers*)(&toTransform->imageSubresource));
+    transform_fromhost_VkOffset3D(resourceTracker, (VkOffset3D*)(&toTransform->imageOffset));
+    transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->imageExtent));
+}
+
+void transform_tohost_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_memory_decompression
+void transform_tohost_VkDecompressMemoryRegionNV(VkDecoderGlobalState* resourceTracker,
+                                                 VkDecompressMemoryRegionNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkDecompressMemoryRegionNV(VkDecoderGlobalState* resourceTracker,
+                                                   VkDecompressMemoryRegionNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_tohost_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_linear_color_attachment
+void transform_tohost_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+void transform_tohost_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_image_processing
+void transform_tohost_VkImageViewSampleWeightCreateInfoQCOM(
+    VkDecoderGlobalState* resourceTracker, VkImageViewSampleWeightCreateInfoQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->filterCenter));
+    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->filterSize));
+}
+
+void transform_fromhost_VkImageViewSampleWeightCreateInfoQCOM(
+    VkDecoderGlobalState* resourceTracker, VkImageViewSampleWeightCreateInfoQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->filterCenter));
+    transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->filterSize));
+}
+
+void transform_tohost_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageProcessingFeaturesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageProcessingFeaturesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageProcessingPropertiesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkExtent2D(resourceTracker,
+                                (VkExtent2D*)(&toTransform->maxWeightFilterDimension));
+    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->maxBlockMatchRegion));
+    transform_tohost_VkExtent2D(resourceTracker,
+                                (VkExtent2D*)(&toTransform->maxBoxFilterBlockSize));
+}
+
+void transform_fromhost_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageProcessingPropertiesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkExtent2D(resourceTracker,
+                                  (VkExtent2D*)(&toTransform->maxWeightFilterDimension));
+    transform_fromhost_VkExtent2D(resourceTracker,
+                                  (VkExtent2D*)(&toTransform->maxBlockMatchRegion));
+    transform_fromhost_VkExtent2D(resourceTracker,
+                                  (VkExtent2D*)(&toTransform->maxBoxFilterBlockSize));
+}
+
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void transform_tohost_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkColorBlendEquationEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkColorBlendEquationEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkColorBlendEquationEXT(VkDecoderGlobalState* resourceTracker,
+                                                VkColorBlendEquationEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_tohost_VkColorBlendAdvancedEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkColorBlendAdvancedEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkColorBlendAdvancedEXT(VkDecoderGlobalState* resourceTracker,
+                                                VkColorBlendAdvancedEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+void transform_tohost_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkRenderPassCreationControlEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkRenderPassCreationControlEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkRenderPassCreationControlEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassCreationControlEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkRenderPassCreationFeedbackInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassCreationFeedbackInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkRenderPassCreationFeedbackInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassCreationFeedbackInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_tohost_VkRenderPassCreationFeedbackCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassCreationFeedbackCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pRenderPassFeedback) {
+        transform_tohost_VkRenderPassCreationFeedbackInfoEXT(
+            resourceTracker,
+            (VkRenderPassCreationFeedbackInfoEXT*)(toTransform->pRenderPassFeedback));
+    }
+}
+
+void transform_fromhost_VkRenderPassCreationFeedbackCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassCreationFeedbackCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pRenderPassFeedback) {
+        transform_fromhost_VkRenderPassCreationFeedbackInfoEXT(
+            resourceTracker,
+            (VkRenderPassCreationFeedbackInfoEXT*)(toTransform->pRenderPassFeedback));
+    }
+}
+
+void transform_tohost_VkRenderPassSubpassFeedbackInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassSubpassFeedbackInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkRenderPassSubpassFeedbackInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassSubpassFeedbackInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_tohost_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassSubpassFeedbackCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pSubpassFeedback) {
+        transform_tohost_VkRenderPassSubpassFeedbackInfoEXT(
+            resourceTracker, (VkRenderPassSubpassFeedbackInfoEXT*)(toTransform->pSubpassFeedback));
+    }
+}
+
+void transform_fromhost_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassSubpassFeedbackCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform->pSubpassFeedback) {
+        transform_fromhost_VkRenderPassSubpassFeedbackInfoEXT(
+            resourceTracker, (VkRenderPassSubpassFeedbackInfoEXT*)(toTransform->pSubpassFeedback));
+    }
+}
+
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+void transform_tohost_VkDirectDriverLoadingInfoLUNARG(
+    VkDecoderGlobalState* resourceTracker, VkDirectDriverLoadingInfoLUNARG* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkDirectDriverLoadingInfoLUNARG(
+    VkDecoderGlobalState* resourceTracker, VkDirectDriverLoadingInfoLUNARG* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDirectDriverLoadingListLUNARG(
+    VkDecoderGlobalState* resourceTracker, VkDirectDriverLoadingListLUNARG* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pDrivers) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->driverCount; ++i) {
+                transform_tohost_VkDirectDriverLoadingInfoLUNARG(
+                    resourceTracker, (VkDirectDriverLoadingInfoLUNARG*)(toTransform->pDrivers + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkDirectDriverLoadingListLUNARG(
+    VkDecoderGlobalState* resourceTracker, VkDirectDriverLoadingListLUNARG* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pDrivers) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->driverCount; ++i) {
+                transform_fromhost_VkDirectDriverLoadingInfoLUNARG(
+                    resourceTracker, (VkDirectDriverLoadingInfoLUNARG*)(toTransform->pDrivers + i));
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void transform_tohost_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkShaderModuleIdentifierEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkShaderModuleIdentifierEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkShaderModuleIdentifierEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkShaderModuleIdentifierEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+void transform_tohost_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceOpticalFlowFeaturesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceOpticalFlowFeaturesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceOpticalFlowPropertiesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceOpticalFlowPropertiesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkOpticalFlowImageFormatInfoNV(VkDecoderGlobalState* resourceTracker,
+                                                     VkOpticalFlowImageFormatInfoNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkOpticalFlowImageFormatInfoNV(
+    VkDecoderGlobalState* resourceTracker, VkOpticalFlowImageFormatInfoNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkOpticalFlowImageFormatPropertiesNV(
+    VkDecoderGlobalState* resourceTracker, VkOpticalFlowImageFormatPropertiesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkOpticalFlowImageFormatPropertiesNV(
+    VkDecoderGlobalState* resourceTracker, VkOpticalFlowImageFormatPropertiesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkOpticalFlowSessionCreateInfoNV(
+    VkDecoderGlobalState* resourceTracker, VkOpticalFlowSessionCreateInfoNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkOpticalFlowSessionCreateInfoNV(
+    VkDecoderGlobalState* resourceTracker, VkOpticalFlowSessionCreateInfoNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkOpticalFlowSessionCreatePrivateDataInfoNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkOpticalFlowSessionCreatePrivateDataInfoNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkOpticalFlowExecuteInfoNV(VkDecoderGlobalState* resourceTracker,
+                                                 VkOpticalFlowExecuteInfoNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_tohost_VkRect2D(resourceTracker, (VkRect2D*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkOpticalFlowExecuteInfoNV(VkDecoderGlobalState* resourceTracker,
+                                                   VkOpticalFlowExecuteInfoNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pRegions) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->regionCount; ++i) {
+                transform_fromhost_VkRect2D(resourceTracker,
+                                            (VkRect2D*)(toTransform->pRegions + i));
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_legacy_dithering
+void transform_tohost_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceLegacyDitheringFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+void transform_tohost_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_shader_object
+void transform_tohost_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderObjectFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderObjectFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderObjectPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderObjectPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkShaderCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                            VkShaderCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pPushConstantRanges) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->pushConstantRangeCount; ++i) {
+                transform_tohost_VkPushConstantRange(
+                    resourceTracker, (VkPushConstantRange*)(toTransform->pPushConstantRanges + i));
+            }
+        }
+    }
+    if (toTransform->pSpecializationInfo) {
+        transform_tohost_VkSpecializationInfo(
+            resourceTracker, (VkSpecializationInfo*)(toTransform->pSpecializationInfo));
+    }
+}
+
+void transform_fromhost_VkShaderCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkShaderCreateInfoEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pPushConstantRanges) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->pushConstantRangeCount; ++i) {
+                transform_fromhost_VkPushConstantRange(
+                    resourceTracker, (VkPushConstantRange*)(toTransform->pPushConstantRanges + i));
+            }
+        }
+    }
+    if (toTransform->pSpecializationInfo) {
+        transform_fromhost_VkSpecializationInfo(
+            resourceTracker, (VkSpecializationInfo*)(toTransform->pSpecializationInfo));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_tile_properties
+void transform_tohost_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceTilePropertiesFeaturesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceTilePropertiesFeaturesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkTilePropertiesQCOM(VkDecoderGlobalState* resourceTracker,
+                                           VkTilePropertiesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_tohost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->tileSize));
+    transform_tohost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->apronSize));
+    transform_tohost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->origin));
+}
+
+void transform_fromhost_VkTilePropertiesQCOM(VkDecoderGlobalState* resourceTracker,
+                                             VkTilePropertiesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    transform_fromhost_VkExtent3D(resourceTracker, (VkExtent3D*)(&toTransform->tileSize));
+    transform_fromhost_VkExtent2D(resourceTracker, (VkExtent2D*)(&toTransform->apronSize));
+    transform_fromhost_VkOffset2D(resourceTracker, (VkOffset2D*)(&toTransform->origin));
+}
+
+#endif
+#ifdef VK_SEC_amigo_profiling
+void transform_tohost_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceAmigoProfilingFeaturesSEC* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceAmigoProfilingFeaturesSEC* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkAmigoProfilingSubmitInfoSEC(VkDecoderGlobalState* resourceTracker,
+                                                    VkAmigoProfilingSubmitInfoSEC* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkAmigoProfilingSubmitInfoSEC(VkDecoderGlobalState* resourceTracker,
+                                                      VkAmigoProfilingSubmitInfoSEC* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+void transform_tohost_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+void transform_tohost_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+void transform_tohost_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+void transform_tohost_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+void transform_tohost_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pPerViewRenderAreas) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->perViewRenderAreaCount; ++i) {
+                transform_tohost_VkRect2D(resourceTracker,
+                                          (VkRect2D*)(toTransform->pPerViewRenderAreas + i));
+            }
+        }
+    }
+}
+
+void transform_fromhost_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+    if (toTransform) {
+        if (toTransform->pPerViewRenderAreas) {
+            for (uint32_t i = 0; i < (uint32_t)toTransform->perViewRenderAreaCount; ++i) {
+                transform_fromhost_VkRect2D(resourceTracker,
+                                            (VkRect2D*)(toTransform->pPerViewRenderAreas + i));
+            }
+        }
+    }
+}
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+void transform_tohost_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* toTransform) {
     (void)resourceTracker;
     (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
 }
 
+void transform_fromhost_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+#endif
+#ifdef VK_KHR_acceleration_structure
 void transform_tohost_VkAccelerationStructureBuildRangeInfoKHR(
     VkDecoderGlobalState* resourceTracker, VkAccelerationStructureBuildRangeInfoKHR* toTransform) {
     (void)resourceTracker;
@@ -16245,6 +19726,56 @@ void transform_fromhost_VkPhysicalDeviceRayQueryFeaturesKHR(
 }
 
 #endif
+#ifdef VK_EXT_mesh_shader
+void transform_tohost_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMeshShaderFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMeshShaderFeaturesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMeshShaderPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_fromhost_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMeshShaderPropertiesEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+    if (toTransform->pNext) {
+        transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+    }
+}
+
+void transform_tohost_VkDrawMeshTasksIndirectCommandEXT(
+    VkDecoderGlobalState* resourceTracker, VkDrawMeshTasksIndirectCommandEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+void transform_fromhost_VkDrawMeshTasksIndirectCommandEXT(
+    VkDecoderGlobalState* resourceTracker, VkDrawMeshTasksIndirectCommandEXT* toTransform) {
+    (void)resourceTracker;
+    (void)toTransform;
+}
+
+#endif
 void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
                                        void* structExtension_out) {
     if (!structExtension_out) {
@@ -16252,6 +19783,13 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
     }
     uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
     switch (structType) {
+#ifdef VK_VERSION_1_0
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
+            transform_tohost_VkShaderModuleCreateInfo(
+                resourceTracker, reinterpret_cast<VkShaderModuleCreateInfo*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_VERSION_1_1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
             transform_tohost_VkPhysicalDeviceSubgroupProperties(
@@ -16728,6 +20266,187 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
+            transform_tohost_VkPhysicalDeviceVulkan13Features(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceVulkan13Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: {
+            transform_tohost_VkPhysicalDeviceVulkan13Properties(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceVulkan13Properties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: {
+            transform_tohost_VkPipelineCreationFeedbackCreateInfo(
+                resourceTracker,
+                reinterpret_cast<VkPipelineCreationFeedbackCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
+            transform_tohost_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
+            transform_tohost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
+            transform_tohost_VkPhysicalDevicePrivateDataFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDevicePrivateDataFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: {
+            transform_tohost_VkDevicePrivateDataCreateInfo(
+                resourceTracker,
+                reinterpret_cast<VkDevicePrivateDataCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
+            transform_tohost_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: {
+            transform_tohost_VkMemoryBarrier2(
+                resourceTracker, reinterpret_cast<VkMemoryBarrier2*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
+            transform_tohost_VkPhysicalDeviceSynchronization2Features(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceSynchronization2Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
+            transform_tohost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
+            transform_tohost_VkPhysicalDeviceImageRobustnessFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceImageRobustnessFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
+            transform_tohost_VkPhysicalDeviceSubgroupSizeControlFeatures(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeatures*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
+            transform_tohost_VkPhysicalDeviceSubgroupSizeControlProperties(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlProperties*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: {
+            transform_tohost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+                resourceTracker,
+                reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
+            transform_tohost_VkPhysicalDeviceInlineUniformBlockFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
+            transform_tohost_VkPhysicalDeviceInlineUniformBlockProperties(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockProperties*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: {
+            transform_tohost_VkWriteDescriptorSetInlineUniformBlock(
+                resourceTracker,
+                reinterpret_cast<VkWriteDescriptorSetInlineUniformBlock*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: {
+            transform_tohost_VkDescriptorPoolInlineUniformBlockCreateInfo(
+                resourceTracker, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
+            transform_tohost_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: {
+            transform_tohost_VkPipelineRenderingCreateInfo(
+                resourceTracker,
+                reinterpret_cast<VkPipelineRenderingCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
+            transform_tohost_VkPhysicalDeviceDynamicRenderingFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: {
+            transform_tohost_VkCommandBufferInheritanceRenderingInfo(
+                resourceTracker,
+                reinterpret_cast<VkCommandBufferInheritanceRenderingInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
+            transform_tohost_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
+            transform_tohost_VkPhysicalDeviceShaderIntegerDotProductProperties(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductProperties*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
+            transform_tohost_VkPhysicalDeviceTexelBufferAlignmentProperties(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentProperties*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
+            transform_tohost_VkFormatProperties3(
+                resourceTracker, reinterpret_cast<VkFormatProperties3*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
+            transform_tohost_VkPhysicalDeviceMaintenance4Features(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMaintenance4Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
+            transform_tohost_VkPhysicalDeviceMaintenance4Properties(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMaintenance4Properties*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_KHR_swapchain
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
             transform_tohost_VkImageSwapchainCreateInfoKHR(
@@ -16762,42 +20481,81 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
         }
 #endif
 #ifdef VK_KHR_video_queue
-        case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
-            transform_tohost_VkVideoQueueFamilyProperties2KHR(
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: {
+            transform_tohost_VkQueueFamilyQueryResultStatusPropertiesKHR(
+                resourceTracker, reinterpret_cast<VkQueueFamilyQueryResultStatusPropertiesKHR*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: {
+            transform_tohost_VkQueueFamilyVideoPropertiesKHR(
                 resourceTracker,
-                reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
+                reinterpret_cast<VkQueueFamilyVideoPropertiesKHR*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
-            transform_tohost_VkVideoProfileKHR(
-                resourceTracker, reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: {
+            transform_tohost_VkVideoProfileInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoProfileInfoKHR*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
-            transform_tohost_VkVideoProfilesKHR(
-                resourceTracker, reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: {
+            transform_tohost_VkVideoProfileListInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoProfileListInfoKHR*>(structExtension_out));
             break;
         }
 #endif
-#ifdef VK_KHR_dynamic_rendering
-        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
-            transform_tohost_VkPipelineRenderingCreateInfoKHR(
+#ifdef VK_KHR_video_decode_queue
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: {
+            transform_tohost_VkVideoDecodeCapabilitiesKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoDecodeCapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: {
+            transform_tohost_VkVideoDecodeUsageInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoDecodeUsageInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_video_decode_h264
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: {
+            transform_tohost_VkVideoDecodeH264ProfileInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoDecodeH264ProfileInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: {
+            transform_tohost_VkVideoDecodeH264CapabilitiesKHR(
                 resourceTracker,
-                reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
+                reinterpret_cast<VkVideoDecodeH264CapabilitiesKHR*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
-            transform_tohost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
-                resourceTracker, reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            transform_tohost_VkVideoDecodeH264SessionParametersAddInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoKHR*>(
                                      structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
-            transform_tohost_VkCommandBufferInheritanceRenderingInfoKHR(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            transform_tohost_VkVideoDecodeH264SessionParametersCreateInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoKHR*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: {
+            transform_tohost_VkVideoDecodeH264PictureInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoDecodeH264PictureInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: {
+            transform_tohost_VkVideoDecodeH264DpbSlotInfoKHR(
                 resourceTracker,
-                reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
+                reinterpret_cast<VkVideoDecodeH264DpbSlotInfoKHR*>(structExtension_out));
             break;
         }
+#endif
+#ifdef VK_KHR_dynamic_rendering
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
             transform_tohost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
                 resourceTracker, reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
@@ -16923,18 +20681,22 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
         }
 #endif
 #ifdef VK_KHR_portability_subset
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
             transform_tohost_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
                 resourceTracker, reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                                      structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
             transform_tohost_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
                 resourceTracker, reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
                                      structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_shader_clock
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
@@ -16944,12 +20706,61 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_KHR_shader_terminate_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
-            transform_tohost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+#ifdef VK_KHR_video_decode_h265
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: {
+            transform_tohost_VkVideoDecodeH265ProfileInfoKHR(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
-                    structExtension_out));
+                reinterpret_cast<VkVideoDecodeH265ProfileInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: {
+            transform_tohost_VkVideoDecodeH265CapabilitiesKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoDecodeH265CapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            transform_tohost_VkVideoDecodeH265SessionParametersAddInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoKHR*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            transform_tohost_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoKHR*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: {
+            transform_tohost_VkVideoDecodeH265PictureInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoDecodeH265PictureInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: {
+            transform_tohost_VkVideoDecodeH265DpbSlotInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoDecodeH265DpbSlotInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: {
+            transform_tohost_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: {
+            transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: {
+            transform_tohost_VkQueueFamilyGlobalPriorityPropertiesKHR(
+                resourceTracker,
+                reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesKHR*>(structExtension_out));
             break;
         }
 #endif
@@ -17005,19 +20816,11 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
-            transform_tohost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-                resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
-            transform_tohost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+#ifdef VK_KHR_pipeline_library
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+            transform_tohost_VkPipelineLibraryCreateInfoKHR(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
-                    structExtension_out));
+                reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(structExtension_out));
             break;
         }
 #endif
@@ -17035,25 +20838,47 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
         }
 #endif
 #ifdef VK_KHR_video_encode_queue
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: {
+            transform_tohost_VkVideoEncodeCapabilitiesKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoEncodeCapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: {
+            transform_tohost_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+                resourceTracker, reinterpret_cast<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(
+                                     structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: {
+            transform_tohost_VkVideoEncodeUsageInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoEncodeUsageInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: {
+            transform_tohost_VkVideoEncodeRateControlLayerInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
             transform_tohost_VkVideoEncodeRateControlInfoKHR(
                 resourceTracker,
                 reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_synchronization2
-        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
-            transform_tohost_VkMemoryBarrier2KHR(
-                resourceTracker, reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
-            transform_tohost_VkPhysicalDeviceSynchronization2FeaturesKHR(
-                resourceTracker, reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(
-                                     structExtension_out));
-            break;
-        }
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
             transform_tohost_VkQueueFamilyCheckpointProperties2NV(
                 resourceTracker,
@@ -17061,20 +20886,27 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_KHR_shader_subgroup_uniform_control_flow
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
-            transform_tohost_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+#ifdef VK_KHR_fragment_shader_barycentric
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
+            transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
+                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: {
+            transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(
                     structExtension_out));
             break;
         }
 #endif
-#ifdef VK_KHR_zero_initialize_workgroup_memory
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
-            transform_tohost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
+#ifdef VK_KHR_shader_subgroup_uniform_control_flow
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
+            transform_tohost_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
+                reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
                     structExtension_out));
             break;
         }
@@ -17088,24 +20920,21 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_KHR_format_feature_flags2
-        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
-            transform_tohost_VkFormatProperties3KHR(
-                resourceTracker, reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
-            break;
-        }
-#endif
-#ifdef VK_KHR_maintenance4
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
-            transform_tohost_VkPhysicalDeviceMaintenance4FeaturesKHR(
+#ifdef VK_KHR_ray_tracing_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
+            transform_tohost_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
+                    structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
-            transform_tohost_VkPhysicalDeviceMaintenance4PropertiesKHR(
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
+            transform_tohost_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(
+                    structExtension_out));
             break;
         }
 #endif
@@ -17174,141 +21003,136 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
         }
 #endif
 #ifdef VK_EXT_video_encode_h264
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
             transform_tohost_VkVideoEncodeH264CapabilitiesEXT(
                 resourceTracker,
                 reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
-            transform_tohost_VkVideoEncodeH264SessionCreateInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
             transform_tohost_VkVideoEncodeH264SessionParametersAddInfoEXT(
                 resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(
                                      structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             transform_tohost_VkVideoEncodeH264SessionParametersCreateInfoEXT(
                 resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
                                      structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
             transform_tohost_VkVideoEncodeH264VclFrameInfoEXT(
                 resourceTracker,
                 reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
-            transform_tohost_VkVideoEncodeH264EmitPictureParametersEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: {
+            transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkVideoEncodeH264DpbSlotInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: {
+            transform_tohost_VkVideoEncodeH264ProfileInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkVideoEncodeH264ProfileInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: {
+            transform_tohost_VkVideoEncodeH264RateControlInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH264RateControlInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
-            transform_tohost_VkVideoEncodeH264ProfileEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: {
+            transform_tohost_VkVideoEncodeH264RateControlLayerInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoEXT*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_EXT_video_encode_h265
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
             transform_tohost_VkVideoEncodeH265CapabilitiesEXT(
                 resourceTracker,
                 reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
-            transform_tohost_VkVideoEncodeH265SessionCreateInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
             transform_tohost_VkVideoEncodeH265SessionParametersAddInfoEXT(
                 resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(
                                      structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             transform_tohost_VkVideoEncodeH265SessionParametersCreateInfoEXT(
                 resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
                                      structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
             transform_tohost_VkVideoEncodeH265VclFrameInfoEXT(
                 resourceTracker,
                 reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
-            transform_tohost_VkVideoEncodeH265EmitPictureParametersEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
-            transform_tohost_VkVideoEncodeH265ProfileEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: {
+            transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265DpbSlotInfoEXT*>(structExtension_out));
             break;
         }
-#endif
-#ifdef VK_EXT_video_decode_h264
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
-            transform_tohost_VkVideoDecodeH264ProfileEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: {
+            transform_tohost_VkVideoEncodeH265ProfileInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265ProfileInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
-            transform_tohost_VkVideoDecodeH264CapabilitiesEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: {
+            transform_tohost_VkVideoEncodeH265RateControlInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265RateControlInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
-            transform_tohost_VkVideoDecodeH264SessionCreateInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: {
+            transform_tohost_VkVideoEncodeH265RateControlLayerInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            transform_tohost_VkVideoDecodeH264SessionParametersAddInfoEXT(
-                resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(
-                                     structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            transform_tohost_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-                resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
-                                     structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
-            transform_tohost_VkVideoDecodeH264PictureInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
-            transform_tohost_VkVideoDecodeH264MvcEXT(
-                resourceTracker, reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
-            transform_tohost_VkVideoDecodeH264DpbSlotInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoEXT*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
@@ -17369,15 +21193,6 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_texture_compression_astc_hdr
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
-            transform_tohost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-                resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_astc_decode_mode
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
             transform_tohost_VkImageViewASTCDecodeModeEXT(
@@ -17392,6 +21207,26 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_robustness
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: {
+            transform_tohost_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: {
+            transform_tohost_VkPipelineRobustnessCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkPipelineRobustnessCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_conditional_rendering
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
             transform_tohost_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
@@ -17493,6 +21328,12 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
         }
 #endif
 #ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+            transform_tohost_VkDebugUtilsObjectNameInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(structExtension_out));
+            break;
+        }
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
             transform_tohost_VkDebugUtilsMessengerCreateInfoEXT(
                 resourceTracker,
@@ -17531,32 +21372,6 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_inline_uniform_block
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
-            transform_tohost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-                resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
-                                     structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
-            transform_tohost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-                resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
-                                     structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
-            transform_tohost_VkWriteDescriptorSetInlineUniformBlockEXT(
-                resourceTracker,
-                reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
-            transform_tohost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-                resourceTracker, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
-                                     structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_sample_locations
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
             transform_tohost_VkSampleLocationsInfoEXT(
@@ -17746,14 +21561,6 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
-            transform_tohost_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_external_memory_host
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
             transform_tohost_VkImportMemoryHostPointerInfoEXT(
@@ -17784,50 +21591,6 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_video_decode_h265
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
-            transform_tohost_VkVideoDecodeH265ProfileEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
-            transform_tohost_VkVideoDecodeH265CapabilitiesEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
-            transform_tohost_VkVideoDecodeH265SessionCreateInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            transform_tohost_VkVideoDecodeH265SessionParametersAddInfoEXT(
-                resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(
-                                     structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            transform_tohost_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-                resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
-                                     structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
-            transform_tohost_VkVideoDecodeH265PictureInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
-            transform_tohost_VkVideoDecodeH265DpbSlotInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
             transform_tohost_VkDeviceMemoryOverallocationCreateInfoAMD(
@@ -17865,14 +21628,6 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_pipeline_creation_feedback
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
-            transform_tohost_VkPipelineCreationFeedbackCreateInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_NV_compute_shader_derivatives
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
             transform_tohost_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
@@ -17896,15 +21651,6 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_NV_fragment_shader_barycentric
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
-            transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-                resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_NV_shader_image_footprint
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
             transform_tohost_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -17995,28 +21741,6 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_subgroup_size_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
-            transform_tohost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-                resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
-                                     structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
-            transform_tohost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-                resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
-            transform_tohost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_AMD_shader_core_properties2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
             transform_tohost_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -18232,14 +21956,57 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
-            transform_tohost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: {
+            transform_tohost_VkSurfacePresentModeEXT(
+                resourceTracker, reinterpret_cast<VkSurfacePresentModeEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
+            transform_tohost_VkSurfacePresentScalingCapabilitiesEXT(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+                reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
+            transform_tohost_VkSurfacePresentModeCompatibilityEXT(
+                resourceTracker,
+                reinterpret_cast<VkSurfacePresentModeCompatibilityEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(
                     structExtension_out));
             break;
         }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: {
+            transform_tohost_VkSwapchainPresentFenceInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkSwapchainPresentFenceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: {
+            transform_tohost_VkSwapchainPresentModesCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkSwapchainPresentModesCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: {
+            transform_tohost_VkSwapchainPresentModeInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkSwapchainPresentModeInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: {
+            transform_tohost_VkSwapchainPresentScalingCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkSwapchainPresentScalingCreateInfoEXT*>(structExtension_out));
+            break;
+        }
 #endif
 #ifdef VK_NV_device_generated_commands
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
@@ -18285,13 +22052,6 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
                                      structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
-            transform_tohost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-                resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
-                    structExtension_out));
-            break;
-        }
 #endif
 #ifdef VK_QCOM_render_pass_transform
         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
@@ -18356,26 +22116,23 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_private_data
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
-            transform_tohost_VkPhysicalDevicePrivateDataFeaturesEXT(
+#ifdef VK_NV_present_barrier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
+            transform_tohost_VkPhysicalDevicePresentBarrierFeaturesNV(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDevicePresentBarrierFeaturesNV*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
-            transform_tohost_VkDevicePrivateDataCreateInfoEXT(
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: {
+            transform_tohost_VkSurfaceCapabilitiesPresentBarrierNV(
                 resourceTracker,
-                reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
+                reinterpret_cast<VkSurfaceCapabilitiesPresentBarrierNV*>(structExtension_out));
             break;
         }
-#endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
-            transform_tohost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: {
+            transform_tohost_VkSwapchainPresentBarrierCreateInfoNV(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
-                    structExtension_out));
+                reinterpret_cast<VkSwapchainPresentBarrierCreateInfoNV*>(structExtension_out));
             break;
         }
 #endif
@@ -18393,6 +22150,147 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_NV_low_latency
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: {
+            transform_tohost_VkQueryLowLatencySupportNV(
+                resourceTracker,
+                reinterpret_cast<VkQueryLowLatencySupportNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_metal_objects
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: {
+            transform_tohost_VkExportMetalObjectCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalObjectCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: {
+            transform_tohost_VkExportMetalDeviceInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalDeviceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: {
+            transform_tohost_VkExportMetalCommandQueueInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalCommandQueueInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: {
+            transform_tohost_VkExportMetalBufferInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalBufferInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: {
+            transform_tohost_VkImportMetalBufferInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkImportMetalBufferInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: {
+            transform_tohost_VkExportMetalTextureInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalTextureInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: {
+            transform_tohost_VkImportMetalTextureInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkImportMetalTextureInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: {
+            transform_tohost_VkExportMetalIOSurfaceInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalIOSurfaceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: {
+            transform_tohost_VkImportMetalIOSurfaceInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkImportMetalIOSurfaceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            transform_tohost_VkExportMetalSharedEventInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalSharedEventInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            transform_tohost_VkImportMetalSharedEventInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkImportMetalSharedEventInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: {
+            transform_tohost_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: {
+            transform_tohost_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: {
+            transform_tohost_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+                resourceTracker,
+                reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: {
+            transform_tohost_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: {
+            transform_tohost_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: {
+            transform_tohost_VkGraphicsPipelineLibraryCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkGraphicsPipelineLibraryCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
+            transform_tohost_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
             transform_tohost_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -18469,11 +22367,33 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_image_robustness
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
-            transform_tohost_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+#ifdef VK_EXT_image_compression_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
+            transform_tohost_VkImageCompressionControlEXT(
+                resourceTracker,
+                reinterpret_cast<VkImageCompressionControlEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
+            transform_tohost_VkImageCompressionPropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkImageCompressionPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(
+                    structExtension_out));
             break;
         }
 #endif
@@ -18485,6 +22405,23 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_device_fault
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceFaultFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceFaultFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_rgba10x6_formats
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
             transform_tohost_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
@@ -18494,17 +22431,17 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
         }
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
-            transform_tohost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+                reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(
                     structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
-            transform_tohost_VkMutableDescriptorTypeCreateInfoVALVE(
+        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: {
+            transform_tohost_VkMutableDescriptorTypeCreateInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
+                reinterpret_cast<VkMutableDescriptorTypeCreateInfoEXT*>(structExtension_out));
             break;
         }
 #endif
@@ -18525,6 +22462,34 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_device_address_binding_report
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: {
+            transform_tohost_VkDeviceAddressBindingCallbackDataEXT(
+                resourceTracker,
+                reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clip_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: {
+            transform_tohost_VkPipelineViewportDepthClipControlCreateInfoEXT(
+                resourceTracker, reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
             transform_tohost_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
@@ -18598,6 +22563,35 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: {
+            transform_tohost_VkSubpassResolvePerformanceQueryEXT(
+                resourceTracker,
+                reinterpret_cast<VkSubpassResolvePerformanceQueryEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: {
+            transform_tohost_VkMultisampledRenderToSingleSampledInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkMultisampledRenderToSingleSampledInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
             transform_tohost_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
@@ -18621,6 +22615,15 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_primitives_generated_query
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_GOOGLE_gfxstream
         case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
             transform_tohost_VkImportColorBufferGOOGLE(
@@ -18638,17 +22641,17 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority_query
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
-            transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
-                resourceTracker, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
-                                     structExtension_out));
+#ifdef VK_EXT_image_view_min_lod
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
-            transform_tohost_VkQueueFamilyGlobalPriorityPropertiesEXT(
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: {
+            transform_tohost_VkImageViewMinLodCreateInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
+                reinterpret_cast<VkImageViewMinLodCreateInfoEXT*>(structExtension_out));
             break;
         }
 #endif
@@ -18666,6 +22669,93 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_tile_image
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: {
+            transform_tohost_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderTileImagePropertiesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: {
+            transform_tohost_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: {
+            transform_tohost_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+                resourceTracker,
+                reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_displacement_micromap
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
+            transform_tohost_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(
+                                     structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: {
+            transform_tohost_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: {
+            transform_tohost_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+                resourceTracker,
+                reinterpret_cast<VkAccelerationStructureTrianglesDisplacementMicromapNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
+            transform_tohost_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: {
+            transform_tohost_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_border_color_swizzle
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
             transform_tohost_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
@@ -18690,6 +22780,365 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_ARM_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: {
+            transform_tohost_VkPhysicalDeviceShaderCorePropertiesARM(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesARM*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: {
+            transform_tohost_VkImageViewSlicedCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkImageViewSlicedCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
+            transform_tohost_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: {
+            transform_tohost_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: {
+            transform_tohost_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: {
+            transform_tohost_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+                resourceTracker, reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_copy_memory_indirect
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
+            transform_tohost_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: {
+            transform_tohost_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_memory_decompression
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: {
+            transform_tohost_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: {
+            transform_tohost_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_linear_color_attachment
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
+            transform_tohost_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_image_processing
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: {
+            transform_tohost_VkImageViewSampleWeightCreateInfoQCOM(
+                resourceTracker,
+                reinterpret_cast<VkImageViewSampleWeightCreateInfoQCOM*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
+            transform_tohost_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: {
+            transform_tohost_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceImageProcessingPropertiesQCOM*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: {
+            transform_tohost_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: {
+            transform_tohost_VkRenderPassCreationControlEXT(
+                resourceTracker,
+                reinterpret_cast<VkRenderPassCreationControlEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+            transform_tohost_VkRenderPassCreationFeedbackCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkRenderPassCreationFeedbackCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: {
+            transform_tohost_VkRenderPassSubpassFeedbackCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkRenderPassSubpassFeedbackCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: {
+            transform_tohost_VkDirectDriverLoadingListLUNARG(
+                resourceTracker,
+                reinterpret_cast<VkDirectDriverLoadingListLUNARG*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_module_identifier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: {
+            transform_tohost_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: {
+            transform_tohost_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_optical_flow
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
+            transform_tohost_VkPhysicalDeviceOpticalFlowFeaturesNV(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceOpticalFlowFeaturesNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: {
+            transform_tohost_VkPhysicalDeviceOpticalFlowPropertiesNV(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceOpticalFlowPropertiesNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: {
+            transform_tohost_VkOpticalFlowImageFormatInfoNV(
+                resourceTracker,
+                reinterpret_cast<VkOpticalFlowImageFormatInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: {
+            transform_tohost_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+                resourceTracker, reinterpret_cast<VkOpticalFlowSessionCreatePrivateDataInfoNV*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_legacy_dithering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_object
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceShaderObjectFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderObjectFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: {
+            transform_tohost_VkPhysicalDeviceShaderObjectPropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderObjectPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_tile_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
+            transform_tohost_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_SEC_amigo_profiling
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
+            transform_tohost_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: {
+            transform_tohost_VkAmigoProfilingSubmitInfoSEC(
+                resourceTracker,
+                reinterpret_cast<VkAmigoProfilingSubmitInfoSEC*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
+            transform_tohost_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: {
+            transform_tohost_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
+            transform_tohost_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ARM_shader_core_builtins
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
+            transform_tohost_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: {
+            transform_tohost_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
+            transform_tohost_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: {
+            transform_tohost_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+                resourceTracker,
+                reinterpret_cast<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
             transform_tohost_VkWriteDescriptorSetAccelerationStructureKHR(
@@ -18734,6 +23183,20 @@ void transform_tohost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_mesh_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
+            transform_tohost_VkPhysicalDeviceMeshShaderFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: {
+            transform_tohost_VkPhysicalDeviceMeshShaderPropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
         default: {
             return;
         }
@@ -18747,6 +23210,13 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
     }
     uint32_t structType = (uint32_t)goldfish_vk_struct_type(structExtension_out);
     switch (structType) {
+#ifdef VK_VERSION_1_0
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: {
+            transform_fromhost_VkShaderModuleCreateInfo(
+                resourceTracker, reinterpret_cast<VkShaderModuleCreateInfo*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_VERSION_1_1
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
             transform_fromhost_VkPhysicalDeviceSubgroupProperties(
@@ -19223,6 +23693,187 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_VERSION_1_3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: {
+            transform_fromhost_VkPhysicalDeviceVulkan13Features(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceVulkan13Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: {
+            transform_fromhost_VkPhysicalDeviceVulkan13Properties(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceVulkan13Properties*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: {
+            transform_fromhost_VkPipelineCreationFeedbackCreateInfo(
+                resourceTracker,
+                reinterpret_cast<VkPipelineCreationFeedbackCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: {
+            transform_fromhost_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: {
+            transform_fromhost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: {
+            transform_fromhost_VkPhysicalDevicePrivateDataFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDevicePrivateDataFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: {
+            transform_fromhost_VkDevicePrivateDataCreateInfo(
+                resourceTracker,
+                reinterpret_cast<VkDevicePrivateDataCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: {
+            transform_fromhost_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: {
+            transform_fromhost_VkMemoryBarrier2(
+                resourceTracker, reinterpret_cast<VkMemoryBarrier2*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: {
+            transform_fromhost_VkPhysicalDeviceSynchronization2Features(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceSynchronization2Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: {
+            transform_fromhost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: {
+            transform_fromhost_VkPhysicalDeviceImageRobustnessFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceImageRobustnessFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: {
+            transform_fromhost_VkPhysicalDeviceSubgroupSizeControlFeatures(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeatures*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: {
+            transform_fromhost_VkPhysicalDeviceSubgroupSizeControlProperties(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlProperties*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: {
+            transform_fromhost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+                resourceTracker,
+                reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfo*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: {
+            transform_fromhost_VkPhysicalDeviceInlineUniformBlockFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: {
+            transform_fromhost_VkPhysicalDeviceInlineUniformBlockProperties(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockProperties*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: {
+            transform_fromhost_VkWriteDescriptorSetInlineUniformBlock(
+                resourceTracker,
+                reinterpret_cast<VkWriteDescriptorSetInlineUniformBlock*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: {
+            transform_fromhost_VkDescriptorPoolInlineUniformBlockCreateInfo(
+                resourceTracker, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfo*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: {
+            transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeatures*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: {
+            transform_fromhost_VkPipelineRenderingCreateInfo(
+                resourceTracker,
+                reinterpret_cast<VkPipelineRenderingCreateInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: {
+            transform_fromhost_VkPhysicalDeviceDynamicRenderingFeatures(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeatures*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: {
+            transform_fromhost_VkCommandBufferInheritanceRenderingInfo(
+                resourceTracker,
+                reinterpret_cast<VkCommandBufferInheritanceRenderingInfo*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: {
+            transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeatures*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: {
+            transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductProperties(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductProperties*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: {
+            transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentProperties(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentProperties*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: {
+            transform_fromhost_VkFormatProperties3(
+                resourceTracker, reinterpret_cast<VkFormatProperties3*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: {
+            transform_fromhost_VkPhysicalDeviceMaintenance4Features(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMaintenance4Features*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: {
+            transform_fromhost_VkPhysicalDeviceMaintenance4Properties(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMaintenance4Properties*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_KHR_swapchain
         case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
             transform_fromhost_VkImageSwapchainCreateInfoKHR(
@@ -19257,42 +23908,81 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
         }
 #endif
 #ifdef VK_KHR_video_queue
-        case VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: {
-            transform_fromhost_VkVideoQueueFamilyProperties2KHR(
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: {
+            transform_fromhost_VkQueueFamilyQueryResultStatusPropertiesKHR(
+                resourceTracker, reinterpret_cast<VkQueueFamilyQueryResultStatusPropertiesKHR*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: {
+            transform_fromhost_VkQueueFamilyVideoPropertiesKHR(
                 resourceTracker,
-                reinterpret_cast<VkVideoQueueFamilyProperties2KHR*>(structExtension_out));
+                reinterpret_cast<VkQueueFamilyVideoPropertiesKHR*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR: {
-            transform_fromhost_VkVideoProfileKHR(
-                resourceTracker, reinterpret_cast<VkVideoProfileKHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: {
+            transform_fromhost_VkVideoProfileInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoProfileInfoKHR*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR: {
-            transform_fromhost_VkVideoProfilesKHR(
-                resourceTracker, reinterpret_cast<VkVideoProfilesKHR*>(structExtension_out));
+        case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: {
+            transform_fromhost_VkVideoProfileListInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoProfileListInfoKHR*>(structExtension_out));
             break;
         }
 #endif
-#ifdef VK_KHR_dynamic_rendering
-        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: {
-            transform_fromhost_VkPipelineRenderingCreateInfoKHR(
+#ifdef VK_KHR_video_decode_queue
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: {
+            transform_fromhost_VkVideoDecodeCapabilitiesKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoDecodeCapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: {
+            transform_fromhost_VkVideoDecodeUsageInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoDecodeUsageInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_video_decode_h264
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: {
+            transform_fromhost_VkVideoDecodeH264ProfileInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoDecodeH264ProfileInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: {
+            transform_fromhost_VkVideoDecodeH264CapabilitiesKHR(
                 resourceTracker,
-                reinterpret_cast<VkPipelineRenderingCreateInfoKHR*>(structExtension_out));
+                reinterpret_cast<VkVideoDecodeH264CapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoKHR*>(
+                                     structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: {
-            transform_fromhost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
-                resourceTracker, reinterpret_cast<VkPhysicalDeviceDynamicRenderingFeaturesKHR*>(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            transform_fromhost_VkVideoDecodeH264SessionParametersCreateInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoKHR*>(
                                      structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: {
-            transform_fromhost_VkCommandBufferInheritanceRenderingInfoKHR(
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: {
+            transform_fromhost_VkVideoDecodeH264PictureInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoDecodeH264PictureInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: {
+            transform_fromhost_VkVideoDecodeH264DpbSlotInfoKHR(
                 resourceTracker,
-                reinterpret_cast<VkCommandBufferInheritanceRenderingInfoKHR*>(structExtension_out));
+                reinterpret_cast<VkVideoDecodeH264DpbSlotInfoKHR*>(structExtension_out));
             break;
         }
+#endif
+#ifdef VK_KHR_dynamic_rendering
         case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: {
             transform_fromhost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
                 resourceTracker, reinterpret_cast<VkRenderingFragmentShadingRateAttachmentInfoKHR*>(
@@ -19418,18 +24108,22 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
         }
 #endif
 #ifdef VK_KHR_portability_subset
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: {
             transform_fromhost_VkPhysicalDevicePortabilitySubsetFeaturesKHR(
                 resourceTracker, reinterpret_cast<VkPhysicalDevicePortabilitySubsetFeaturesKHR*>(
                                      structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: {
             transform_fromhost_VkPhysicalDevicePortabilitySubsetPropertiesKHR(
                 resourceTracker, reinterpret_cast<VkPhysicalDevicePortabilitySubsetPropertiesKHR*>(
                                      structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_shader_clock
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: {
@@ -19439,12 +24133,61 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_KHR_shader_terminate_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: {
-            transform_fromhost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
+#ifdef VK_KHR_video_decode_h265
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: {
+            transform_fromhost_VkVideoDecodeH265ProfileInfoKHR(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR*>(
-                    structExtension_out));
+                reinterpret_cast<VkVideoDecodeH265ProfileInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: {
+            transform_fromhost_VkVideoDecodeH265CapabilitiesKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoDecodeH265CapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: {
+            transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoKHR*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: {
+            transform_fromhost_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoKHR*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: {
+            transform_fromhost_VkVideoDecodeH265PictureInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoDecodeH265PictureInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: {
+            transform_fromhost_VkVideoDecodeH265DpbSlotInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoDecodeH265DpbSlotInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_KHR_global_priority
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: {
+            transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoKHR*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: {
+            transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: {
+            transform_fromhost_VkQueueFamilyGlobalPriorityPropertiesKHR(
+                resourceTracker,
+                reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesKHR*>(structExtension_out));
             break;
         }
 #endif
@@ -19500,19 +24243,11 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_KHR_shader_integer_dot_product
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: {
-            transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-                resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: {
-            transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
+#ifdef VK_KHR_pipeline_library
+        case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: {
+            transform_fromhost_VkPipelineLibraryCreateInfoKHR(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR*>(
-                    structExtension_out));
+                reinterpret_cast<VkPipelineLibraryCreateInfoKHR*>(structExtension_out));
             break;
         }
 #endif
@@ -19530,25 +24265,47 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
         }
 #endif
 #ifdef VK_KHR_video_encode_queue
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: {
+            transform_fromhost_VkVideoEncodeCapabilitiesKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoEncodeCapabilitiesKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: {
+            transform_fromhost_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+                resourceTracker, reinterpret_cast<VkQueryPoolVideoEncodeFeedbackCreateInfoKHR*>(
+                                     structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: {
+            transform_fromhost_VkVideoEncodeUsageInfoKHR(
+                resourceTracker, reinterpret_cast<VkVideoEncodeUsageInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: {
+            transform_fromhost_VkVideoEncodeRateControlLayerInfoKHR(
+                resourceTracker,
+                reinterpret_cast<VkVideoEncodeRateControlLayerInfoKHR*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: {
             transform_fromhost_VkVideoEncodeRateControlInfoKHR(
                 resourceTracker,
                 reinterpret_cast<VkVideoEncodeRateControlInfoKHR*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_KHR_synchronization2
-        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: {
-            transform_fromhost_VkMemoryBarrier2KHR(
-                resourceTracker, reinterpret_cast<VkMemoryBarrier2KHR*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: {
-            transform_fromhost_VkPhysicalDeviceSynchronization2FeaturesKHR(
-                resourceTracker, reinterpret_cast<VkPhysicalDeviceSynchronization2FeaturesKHR*>(
-                                     structExtension_out));
-            break;
-        }
         case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: {
             transform_fromhost_VkQueueFamilyCheckpointProperties2NV(
                 resourceTracker,
@@ -19556,20 +24313,27 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_KHR_shader_subgroup_uniform_control_flow
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
-            transform_fromhost_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
+#ifdef VK_KHR_fragment_shader_barycentric
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: {
+            transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
+                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: {
+            transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR*>(
                     structExtension_out));
             break;
         }
 #endif
-#ifdef VK_KHR_zero_initialize_workgroup_memory
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: {
-            transform_fromhost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
+#ifdef VK_KHR_shader_subgroup_uniform_control_flow
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: {
+            transform_fromhost_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR*>(
+                reinterpret_cast<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR*>(
                     structExtension_out));
             break;
         }
@@ -19583,24 +24347,21 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_KHR_format_feature_flags2
-        case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: {
-            transform_fromhost_VkFormatProperties3KHR(
-                resourceTracker, reinterpret_cast<VkFormatProperties3KHR*>(structExtension_out));
-            break;
-        }
-#endif
-#ifdef VK_KHR_maintenance4
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: {
-            transform_fromhost_VkPhysicalDeviceMaintenance4FeaturesKHR(
+#ifdef VK_KHR_ray_tracing_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: {
+            transform_fromhost_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceMaintenance4FeaturesKHR*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR*>(
+                    structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: {
-            transform_fromhost_VkPhysicalDeviceMaintenance4PropertiesKHR(
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: {
+            transform_fromhost_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceMaintenance4PropertiesKHR*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR*>(
+                    structExtension_out));
             break;
         }
 #endif
@@ -19669,141 +24430,136 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
         }
 #endif
 #ifdef VK_EXT_video_encode_h264
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: {
             transform_fromhost_VkVideoEncodeH264CapabilitiesEXT(
                 resourceTracker,
                 reinterpret_cast<VkVideoEncodeH264CapabilitiesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT: {
-            transform_fromhost_VkVideoEncodeH264SessionCreateInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoEncodeH264SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
             transform_fromhost_VkVideoEncodeH264SessionParametersAddInfoEXT(
                 resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionParametersAddInfoEXT*>(
                                      structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             transform_fromhost_VkVideoEncodeH264SessionParametersCreateInfoEXT(
                 resourceTracker, reinterpret_cast<VkVideoEncodeH264SessionParametersCreateInfoEXT*>(
                                      structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: {
             transform_fromhost_VkVideoEncodeH264VclFrameInfoEXT(
                 resourceTracker,
                 reinterpret_cast<VkVideoEncodeH264VclFrameInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: {
-            transform_fromhost_VkVideoEncodeH264EmitPictureParametersEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: {
+            transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkVideoEncodeH264DpbSlotInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: {
+            transform_fromhost_VkVideoEncodeH264ProfileInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkVideoEncodeH264ProfileInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: {
+            transform_fromhost_VkVideoEncodeH264RateControlInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkVideoEncodeH264EmitPictureParametersEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH264RateControlInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT: {
-            transform_fromhost_VkVideoEncodeH264ProfileEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: {
+            transform_fromhost_VkVideoEncodeH264RateControlLayerInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkVideoEncodeH264ProfileEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH264RateControlLayerInfoEXT*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_EXT_video_encode_h265
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: {
             transform_fromhost_VkVideoEncodeH265CapabilitiesEXT(
                 resourceTracker,
                 reinterpret_cast<VkVideoEncodeH265CapabilitiesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT: {
-            transform_fromhost_VkVideoEncodeH265SessionCreateInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoEncodeH265SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
             transform_fromhost_VkVideoEncodeH265SessionParametersAddInfoEXT(
                 resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionParametersAddInfoEXT*>(
                                      structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
             transform_fromhost_VkVideoEncodeH265SessionParametersCreateInfoEXT(
                 resourceTracker, reinterpret_cast<VkVideoEncodeH265SessionParametersCreateInfoEXT*>(
                                      structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
         case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: {
             transform_fromhost_VkVideoEncodeH265VclFrameInfoEXT(
                 resourceTracker,
                 reinterpret_cast<VkVideoEncodeH265VclFrameInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: {
-            transform_fromhost_VkVideoEncodeH265EmitPictureParametersEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoEncodeH265EmitPictureParametersEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT: {
-            transform_fromhost_VkVideoEncodeH265ProfileEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoEncodeH265ProfileEXT*>(structExtension_out));
-            break;
-        }
-#endif
-#ifdef VK_EXT_video_decode_h264
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT: {
-            transform_fromhost_VkVideoDecodeH264ProfileEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: {
+            transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkVideoDecodeH264ProfileEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265DpbSlotInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: {
-            transform_fromhost_VkVideoDecodeH264CapabilitiesEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: {
+            transform_fromhost_VkVideoEncodeH265ProfileInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkVideoDecodeH264CapabilitiesEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265ProfileInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_CREATE_INFO_EXT: {
-            transform_fromhost_VkVideoDecodeH264SessionCreateInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: {
+            transform_fromhost_VkVideoEncodeH265RateControlInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkVideoDecodeH264SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoEXT(
-                resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersAddInfoEXT*>(
-                                     structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            transform_fromhost_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-                resourceTracker, reinterpret_cast<VkVideoDecodeH264SessionParametersCreateInfoEXT*>(
-                                     structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265RateControlInfoEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: {
-            transform_fromhost_VkVideoDecodeH264PictureInfoEXT(
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: {
+            transform_fromhost_VkVideoEncodeH265RateControlLayerInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkVideoDecodeH264PictureInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT: {
-            transform_fromhost_VkVideoDecodeH264MvcEXT(
-                resourceTracker, reinterpret_cast<VkVideoDecodeH264MvcEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: {
-            transform_fromhost_VkVideoDecodeH264DpbSlotInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoDecodeH264DpbSlotInfoEXT*>(structExtension_out));
+                reinterpret_cast<VkVideoEncodeH265RateControlLayerInfoEXT*>(structExtension_out));
             break;
         }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
         case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
@@ -19864,15 +24620,6 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_texture_compression_astc_hdr
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
-            transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-                resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_astc_decode_mode
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
             transform_fromhost_VkImageViewASTCDecodeModeEXT(
@@ -19887,6 +24634,26 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_robustness
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDevicePipelineRobustnessFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: {
+            transform_fromhost_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDevicePipelineRobustnessPropertiesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: {
+            transform_fromhost_VkPipelineRobustnessCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkPipelineRobustnessCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_conditional_rendering
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
             transform_fromhost_VkPhysicalDeviceConditionalRenderingFeaturesEXT(
@@ -19988,6 +24755,12 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
         }
 #endif
 #ifdef VK_EXT_debug_utils
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+            transform_fromhost_VkDebugUtilsObjectNameInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(structExtension_out));
+            break;
+        }
         case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
             transform_fromhost_VkDebugUtilsMessengerCreateInfoEXT(
                 resourceTracker,
@@ -20026,32 +24799,6 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_inline_uniform_block
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
-            transform_fromhost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-                resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockFeaturesEXT*>(
-                                     structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
-            transform_fromhost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-                resourceTracker, reinterpret_cast<VkPhysicalDeviceInlineUniformBlockPropertiesEXT*>(
-                                     structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
-            transform_fromhost_VkWriteDescriptorSetInlineUniformBlockEXT(
-                resourceTracker,
-                reinterpret_cast<VkWriteDescriptorSetInlineUniformBlockEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
-            transform_fromhost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-                resourceTracker, reinterpret_cast<VkDescriptorPoolInlineUniformBlockCreateInfoEXT*>(
-                                     structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_sample_locations
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
             transform_fromhost_VkSampleLocationsInfoEXT(
@@ -20241,14 +24988,6 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority
-        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
-            transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkDeviceQueueGlobalPriorityCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_EXT_external_memory_host
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
             transform_fromhost_VkImportMemoryHostPointerInfoEXT(
@@ -20279,50 +25018,6 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_video_decode_h265
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT: {
-            transform_fromhost_VkVideoDecodeH265ProfileEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoDecodeH265ProfileEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: {
-            transform_fromhost_VkVideoDecodeH265CapabilitiesEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoDecodeH265CapabilitiesEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_CREATE_INFO_EXT: {
-            transform_fromhost_VkVideoDecodeH265SessionCreateInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoDecodeH265SessionCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: {
-            transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoEXT(
-                resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersAddInfoEXT*>(
-                                     structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: {
-            transform_fromhost_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-                resourceTracker, reinterpret_cast<VkVideoDecodeH265SessionParametersCreateInfoEXT*>(
-                                     structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: {
-            transform_fromhost_VkVideoDecodeH265PictureInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoDecodeH265PictureInfoEXT*>(structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: {
-            transform_fromhost_VkVideoDecodeH265DpbSlotInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkVideoDecodeH265DpbSlotInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
             transform_fromhost_VkDeviceMemoryOverallocationCreateInfoAMD(
@@ -20360,14 +25055,6 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_pipeline_creation_feedback
-        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
-            transform_fromhost_VkPipelineCreationFeedbackCreateInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkPipelineCreationFeedbackCreateInfoEXT*>(structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_NV_compute_shader_derivatives
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
             transform_fromhost_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(
@@ -20391,15 +25078,6 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_NV_fragment_shader_barycentric
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
-            transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-                resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_NV_shader_image_footprint
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
             transform_fromhost_VkPhysicalDeviceShaderImageFootprintFeaturesNV(
@@ -20490,28 +25168,6 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_subgroup_size_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
-            transform_fromhost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-                resourceTracker, reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT*>(
-                                     structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: {
-            transform_fromhost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-                resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT*>(
-                    structExtension_out));
-            break;
-        }
-        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: {
-            transform_fromhost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-                resourceTracker,
-                reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT*>(
-                    structExtension_out));
-            break;
-        }
-#endif
 #ifdef VK_AMD_shader_core_properties2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: {
             transform_fromhost_VkPhysicalDeviceShaderCoreProperties2AMD(
@@ -20727,14 +25383,57 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
-            transform_fromhost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: {
+            transform_fromhost_VkSurfacePresentModeEXT(
+                resourceTracker, reinterpret_cast<VkSurfacePresentModeEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: {
+            transform_fromhost_VkSurfacePresentScalingCapabilitiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkSurfacePresentScalingCapabilitiesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: {
+            transform_fromhost_VkSurfacePresentModeCompatibilityEXT(
+                resourceTracker,
+                reinterpret_cast<VkSurfacePresentModeCompatibilityEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT*>(
+                reinterpret_cast<VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT*>(
                     structExtension_out));
             break;
         }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: {
+            transform_fromhost_VkSwapchainPresentFenceInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkSwapchainPresentFenceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: {
+            transform_fromhost_VkSwapchainPresentModesCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkSwapchainPresentModesCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: {
+            transform_fromhost_VkSwapchainPresentModeInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkSwapchainPresentModeInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: {
+            transform_fromhost_VkSwapchainPresentScalingCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkSwapchainPresentScalingCreateInfoEXT*>(structExtension_out));
+            break;
+        }
 #endif
 #ifdef VK_NV_device_generated_commands
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: {
@@ -20780,13 +25479,6 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
                                      structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
-            transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-                resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT*>(
-                    structExtension_out));
-            break;
-        }
 #endif
 #ifdef VK_QCOM_render_pass_transform
         case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: {
@@ -20851,26 +25543,23 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_private_data
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: {
-            transform_fromhost_VkPhysicalDevicePrivateDataFeaturesEXT(
+#ifdef VK_NV_present_barrier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: {
+            transform_fromhost_VkPhysicalDevicePresentBarrierFeaturesNV(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDevicePrivateDataFeaturesEXT*>(structExtension_out));
+                reinterpret_cast<VkPhysicalDevicePresentBarrierFeaturesNV*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: {
-            transform_fromhost_VkDevicePrivateDataCreateInfoEXT(
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: {
+            transform_fromhost_VkSurfaceCapabilitiesPresentBarrierNV(
                 resourceTracker,
-                reinterpret_cast<VkDevicePrivateDataCreateInfoEXT*>(structExtension_out));
+                reinterpret_cast<VkSurfaceCapabilitiesPresentBarrierNV*>(structExtension_out));
             break;
         }
-#endif
-#ifdef VK_EXT_pipeline_creation_cache_control
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
-            transform_fromhost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: {
+            transform_fromhost_VkSwapchainPresentBarrierCreateInfoNV(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT*>(
-                    structExtension_out));
+                reinterpret_cast<VkSwapchainPresentBarrierCreateInfoNV*>(structExtension_out));
             break;
         }
 #endif
@@ -20888,6 +25577,147 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_NV_low_latency
+        case VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: {
+            transform_fromhost_VkQueryLowLatencySupportNV(
+                resourceTracker,
+                reinterpret_cast<VkQueryLowLatencySupportNV*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_metal_objects
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: {
+            transform_fromhost_VkExportMetalObjectCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalObjectCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: {
+            transform_fromhost_VkExportMetalDeviceInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalDeviceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: {
+            transform_fromhost_VkExportMetalCommandQueueInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalCommandQueueInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: {
+            transform_fromhost_VkExportMetalBufferInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalBufferInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: {
+            transform_fromhost_VkImportMetalBufferInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkImportMetalBufferInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: {
+            transform_fromhost_VkExportMetalTextureInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalTextureInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: {
+            transform_fromhost_VkImportMetalTextureInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkImportMetalTextureInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: {
+            transform_fromhost_VkExportMetalIOSurfaceInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalIOSurfaceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: {
+            transform_fromhost_VkImportMetalIOSurfaceInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkImportMetalIOSurfaceInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            transform_fromhost_VkExportMetalSharedEventInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkExportMetalSharedEventInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: {
+            transform_fromhost_VkImportMetalSharedEventInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkImportMetalSharedEventInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_descriptor_buffer
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: {
+            transform_fromhost_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceDescriptorBufferPropertiesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: {
+            transform_fromhost_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceDescriptorBufferFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: {
+            transform_fromhost_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+                resourceTracker,
+                reinterpret_cast<VkDescriptorBufferBindingPushDescriptorBufferHandleEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: {
+            transform_fromhost_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkOpaqueCaptureDescriptorDataCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: {
+            transform_fromhost_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: {
+            transform_fromhost_VkGraphicsPipelineLibraryCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkGraphicsPipelineLibraryCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: {
+            transform_fromhost_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: {
             transform_fromhost_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
@@ -20964,11 +25794,33 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_image_robustness
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
-            transform_fromhost_VkPhysicalDeviceImageRobustnessFeaturesEXT(
+#ifdef VK_EXT_image_compression_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceImageCompressionControlFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: {
+            transform_fromhost_VkImageCompressionControlEXT(
+                resourceTracker,
+                reinterpret_cast<VkImageCompressionControlEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: {
+            transform_fromhost_VkImageCompressionPropertiesEXT(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT*>(structExtension_out));
+                reinterpret_cast<VkImageCompressionPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT*>(
+                    structExtension_out));
             break;
         }
 #endif
@@ -20980,6 +25832,23 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_device_fault
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceFaultFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceFaultFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_rgba10x6_formats
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: {
             transform_fromhost_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
@@ -20989,17 +25858,17 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
         }
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: {
-            transform_fromhost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
                 resourceTracker,
-                reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE*>(
+                reinterpret_cast<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT*>(
                     structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: {
-            transform_fromhost_VkMutableDescriptorTypeCreateInfoVALVE(
+        case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: {
+            transform_fromhost_VkMutableDescriptorTypeCreateInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkMutableDescriptorTypeCreateInfoVALVE*>(structExtension_out));
+                reinterpret_cast<VkMutableDescriptorTypeCreateInfoEXT*>(structExtension_out));
             break;
         }
 #endif
@@ -21020,6 +25889,34 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_device_address_binding_report
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceAddressBindingReportFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: {
+            transform_fromhost_VkDeviceAddressBindingCallbackDataEXT(
+                resourceTracker,
+                reinterpret_cast<VkDeviceAddressBindingCallbackDataEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clip_control
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceDepthClipControlFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: {
+            transform_fromhost_VkPipelineViewportDepthClipControlCreateInfoEXT(
+                resourceTracker, reinterpret_cast<VkPipelineViewportDepthClipControlCreateInfoEXT*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: {
             transform_fromhost_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
@@ -21093,6 +25990,35 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_pipeline_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDevicePipelinePropertiesFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: {
+            transform_fromhost_VkSubpassResolvePerformanceQueryEXT(
+                resourceTracker,
+                reinterpret_cast<VkSubpassResolvePerformanceQueryEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: {
+            transform_fromhost_VkMultisampledRenderToSingleSampledInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkMultisampledRenderToSingleSampledInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: {
             transform_fromhost_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
@@ -21116,6 +26042,15 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_primitives_generated_query
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_GOOGLE_gfxstream
         case VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE: {
             transform_fromhost_VkImportColorBufferGOOGLE(
@@ -21133,17 +26068,17 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
-#ifdef VK_EXT_global_priority_query
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: {
-            transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
-                resourceTracker, reinterpret_cast<VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT*>(
-                                     structExtension_out));
+#ifdef VK_EXT_image_view_min_lod
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceImageViewMinLodFeaturesEXT*>(structExtension_out));
             break;
         }
-        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: {
-            transform_fromhost_VkQueueFamilyGlobalPriorityPropertiesEXT(
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: {
+            transform_fromhost_VkImageViewMinLodCreateInfoEXT(
                 resourceTracker,
-                reinterpret_cast<VkQueueFamilyGlobalPriorityPropertiesEXT*>(structExtension_out));
+                reinterpret_cast<VkImageViewMinLodCreateInfoEXT*>(structExtension_out));
             break;
         }
 #endif
@@ -21161,6 +26096,93 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_tile_image
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderTileImageFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: {
+            transform_fromhost_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderTileImagePropertiesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_opacity_micromap
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceOpacityMicromapFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: {
+            transform_fromhost_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceOpacityMicromapPropertiesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: {
+            transform_fromhost_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+                resourceTracker,
+                reinterpret_cast<VkAccelerationStructureTrianglesOpacityMicromapEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_displacement_micromap
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: {
+            transform_fromhost_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceDisplacementMicromapFeaturesNV*>(
+                                     structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: {
+            transform_fromhost_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceDisplacementMicromapPropertiesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#ifdef VK_ENABLE_BETA_EXTENSIONS
+        case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: {
+            transform_fromhost_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+                resourceTracker,
+                reinterpret_cast<VkAccelerationStructureTrianglesDisplacementMicromapNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif  // VK_ENABLE_BETA_EXTENSIONS
+#endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: {
+            transform_fromhost_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: {
+            transform_fromhost_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_EXT_border_color_swizzle
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: {
             transform_fromhost_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
@@ -21185,6 +26207,365 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_ARM_shader_core_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: {
+            transform_fromhost_VkPhysicalDeviceShaderCorePropertiesARM(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderCorePropertiesARM*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: {
+            transform_fromhost_VkImageViewSlicedCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkImageViewSlicedCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: {
+            transform_fromhost_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: {
+            transform_fromhost_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: {
+            transform_fromhost_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: {
+            transform_fromhost_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+                resourceTracker, reinterpret_cast<VkSubpassFragmentDensityMapOffsetEndInfoQCOM*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_copy_memory_indirect
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: {
+            transform_fromhost_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectFeaturesNV*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: {
+            transform_fromhost_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceCopyMemoryIndirectPropertiesNV*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_memory_decompression
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: {
+            transform_fromhost_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceMemoryDecompressionFeaturesNV*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: {
+            transform_fromhost_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceMemoryDecompressionPropertiesNV*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_linear_color_attachment
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: {
+            transform_fromhost_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceLinearColorAttachmentFeaturesNV*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_image_processing
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: {
+            transform_fromhost_VkImageViewSampleWeightCreateInfoQCOM(
+                resourceTracker,
+                reinterpret_cast<VkImageViewSampleWeightCreateInfoQCOM*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: {
+            transform_fromhost_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceImageProcessingFeaturesQCOM*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: {
+            transform_fromhost_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceImageProcessingPropertiesQCOM*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3FeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: {
+            transform_fromhost_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceExtendedDynamicState3PropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: {
+            transform_fromhost_VkRenderPassCreationControlEXT(
+                resourceTracker,
+                reinterpret_cast<VkRenderPassCreationControlEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: {
+            transform_fromhost_VkRenderPassCreationFeedbackCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkRenderPassCreationFeedbackCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: {
+            transform_fromhost_VkRenderPassSubpassFeedbackCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkRenderPassSubpassFeedbackCreateInfoEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+        case VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: {
+            transform_fromhost_VkDirectDriverLoadingListLUNARG(
+                resourceTracker,
+                reinterpret_cast<VkDirectDriverLoadingListLUNARG*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_module_identifier
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: {
+            transform_fromhost_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: {
+            transform_fromhost_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+                resourceTracker,
+                reinterpret_cast<VkPipelineShaderStageModuleIdentifierCreateInfoEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_optical_flow
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: {
+            transform_fromhost_VkPhysicalDeviceOpticalFlowFeaturesNV(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceOpticalFlowFeaturesNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: {
+            transform_fromhost_VkPhysicalDeviceOpticalFlowPropertiesNV(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceOpticalFlowPropertiesNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: {
+            transform_fromhost_VkOpticalFlowImageFormatInfoNV(
+                resourceTracker,
+                reinterpret_cast<VkOpticalFlowImageFormatInfoNV*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: {
+            transform_fromhost_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+                resourceTracker, reinterpret_cast<VkOpticalFlowSessionCreatePrivateDataInfoNV*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_legacy_dithering
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceLegacyDitheringFeaturesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_shader_object
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceShaderObjectFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderObjectFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: {
+            transform_fromhost_VkPhysicalDeviceShaderObjectPropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceShaderObjectPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_tile_properties
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: {
+            transform_fromhost_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceTilePropertiesFeaturesQCOM*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_SEC_amigo_profiling
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: {
+            transform_fromhost_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceAmigoProfilingFeaturesSEC*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: {
+            transform_fromhost_VkAmigoProfilingSubmitInfoSEC(
+                resourceTracker,
+                reinterpret_cast<VkAmigoProfilingSubmitInfoSEC*>(structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: {
+            transform_fromhost_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: {
+            transform_fromhost_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: {
+            transform_fromhost_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_ARM_shader_core_builtins
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: {
+            transform_fromhost_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM*>(
+                                     structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: {
+            transform_fromhost_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+                resourceTracker, reinterpret_cast<VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM*>(
+                                     structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: {
+            transform_fromhost_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM*>(
+                    structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: {
+            transform_fromhost_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+                resourceTracker,
+                reinterpret_cast<VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM*>(
+                    structExtension_out));
+            break;
+        }
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT*>(
+                    structExtension_out));
+            break;
+        }
+#endif
 #ifdef VK_KHR_acceleration_structure
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: {
             transform_fromhost_VkWriteDescriptorSetAccelerationStructureKHR(
@@ -21229,6 +26610,20 @@ void transform_fromhost_extension_struct(VkDecoderGlobalState* resourceTracker,
             break;
         }
 #endif
+#ifdef VK_EXT_mesh_shader
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: {
+            transform_fromhost_VkPhysicalDeviceMeshShaderFeaturesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMeshShaderFeaturesEXT*>(structExtension_out));
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: {
+            transform_fromhost_VkPhysicalDeviceMeshShaderPropertiesEXT(
+                resourceTracker,
+                reinterpret_cast<VkPhysicalDeviceMeshShaderPropertiesEXT*>(structExtension_out));
+            break;
+        }
+#endif
         default: {
             return;
         }
diff --git a/stream-servers/vulkan/cereal/common/goldfish_vk_transform.h b/stream-servers/vulkan/cereal/common/goldfish_vk_transform.h
index 9f46b04c..ae263372 100644
--- a/stream-servers/vulkan/cereal/common/goldfish_vk_transform.h
+++ b/stream-servers/vulkan/cereal/common/goldfish_vk_transform.h
@@ -15,8 +15,8 @@
 
 // Autogenerated module goldfish_vk_transform
 //
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (header) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -1468,6 +1468,352 @@ void transform_fromhost_VkDeviceMemoryOpaqueCaptureAddressInfo(
     VkDecoderGlobalState* resourceTracker, VkDeviceMemoryOpaqueCaptureAddressInfo* toTransform);
 
 #endif
+#ifdef VK_VERSION_1_3
+void transform_tohost_VkPhysicalDeviceVulkan13Features(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceVulkan13Features* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceVulkan13Features(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceVulkan13Features* toTransform);
+
+void transform_tohost_VkPhysicalDeviceVulkan13Properties(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceVulkan13Properties* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceVulkan13Properties(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceVulkan13Properties* toTransform);
+
+void transform_tohost_VkPipelineCreationFeedback(VkDecoderGlobalState* resourceTracker,
+                                                 VkPipelineCreationFeedback* toTransform);
+
+void transform_fromhost_VkPipelineCreationFeedback(VkDecoderGlobalState* resourceTracker,
+                                                   VkPipelineCreationFeedback* toTransform);
+
+void transform_tohost_VkPipelineCreationFeedbackCreateInfo(
+    VkDecoderGlobalState* resourceTracker, VkPipelineCreationFeedbackCreateInfo* toTransform);
+
+void transform_fromhost_VkPipelineCreationFeedbackCreateInfo(
+    VkDecoderGlobalState* resourceTracker, VkPipelineCreationFeedbackCreateInfo* toTransform);
+
+void transform_tohost_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderTerminateInvocationFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderTerminateInvocationFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderTerminateInvocationFeatures* toTransform);
+
+void transform_tohost_VkPhysicalDeviceToolProperties(VkDecoderGlobalState* resourceTracker,
+                                                     VkPhysicalDeviceToolProperties* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceToolProperties(VkDecoderGlobalState* resourceTracker,
+                                                       VkPhysicalDeviceToolProperties* toTransform);
+
+void transform_tohost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures* toTransform);
+
+void transform_tohost_VkPhysicalDevicePrivateDataFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDevicePrivateDataFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePrivateDataFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDevicePrivateDataFeatures* toTransform);
+
+void transform_tohost_VkDevicePrivateDataCreateInfo(VkDecoderGlobalState* resourceTracker,
+                                                    VkDevicePrivateDataCreateInfo* toTransform);
+
+void transform_fromhost_VkDevicePrivateDataCreateInfo(VkDecoderGlobalState* resourceTracker,
+                                                      VkDevicePrivateDataCreateInfo* toTransform);
+
+void transform_tohost_VkPrivateDataSlotCreateInfo(VkDecoderGlobalState* resourceTracker,
+                                                  VkPrivateDataSlotCreateInfo* toTransform);
+
+void transform_fromhost_VkPrivateDataSlotCreateInfo(VkDecoderGlobalState* resourceTracker,
+                                                    VkPrivateDataSlotCreateInfo* toTransform);
+
+void transform_tohost_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineCreationCacheControlFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePipelineCreationCacheControlFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineCreationCacheControlFeatures* toTransform);
+
+void transform_tohost_VkMemoryBarrier2(VkDecoderGlobalState* resourceTracker,
+                                       VkMemoryBarrier2* toTransform);
+
+void transform_fromhost_VkMemoryBarrier2(VkDecoderGlobalState* resourceTracker,
+                                         VkMemoryBarrier2* toTransform);
+
+void transform_tohost_VkBufferMemoryBarrier2(VkDecoderGlobalState* resourceTracker,
+                                             VkBufferMemoryBarrier2* toTransform);
+
+void transform_fromhost_VkBufferMemoryBarrier2(VkDecoderGlobalState* resourceTracker,
+                                               VkBufferMemoryBarrier2* toTransform);
+
+void transform_tohost_VkImageMemoryBarrier2(VkDecoderGlobalState* resourceTracker,
+                                            VkImageMemoryBarrier2* toTransform);
+
+void transform_fromhost_VkImageMemoryBarrier2(VkDecoderGlobalState* resourceTracker,
+                                              VkImageMemoryBarrier2* toTransform);
+
+void transform_tohost_VkDependencyInfo(VkDecoderGlobalState* resourceTracker,
+                                       VkDependencyInfo* toTransform);
+
+void transform_fromhost_VkDependencyInfo(VkDecoderGlobalState* resourceTracker,
+                                         VkDependencyInfo* toTransform);
+
+void transform_tohost_VkSemaphoreSubmitInfo(VkDecoderGlobalState* resourceTracker,
+                                            VkSemaphoreSubmitInfo* toTransform);
+
+void transform_fromhost_VkSemaphoreSubmitInfo(VkDecoderGlobalState* resourceTracker,
+                                              VkSemaphoreSubmitInfo* toTransform);
+
+void transform_tohost_VkCommandBufferSubmitInfo(VkDecoderGlobalState* resourceTracker,
+                                                VkCommandBufferSubmitInfo* toTransform);
+
+void transform_fromhost_VkCommandBufferSubmitInfo(VkDecoderGlobalState* resourceTracker,
+                                                  VkCommandBufferSubmitInfo* toTransform);
+
+void transform_tohost_VkSubmitInfo2(VkDecoderGlobalState* resourceTracker,
+                                    VkSubmitInfo2* toTransform);
+
+void transform_fromhost_VkSubmitInfo2(VkDecoderGlobalState* resourceTracker,
+                                      VkSubmitInfo2* toTransform);
+
+void transform_tohost_VkPhysicalDeviceSynchronization2Features(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceSynchronization2Features* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceSynchronization2Features(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceSynchronization2Features* toTransform);
+
+void transform_tohost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures* toTransform);
+
+void transform_tohost_VkPhysicalDeviceImageRobustnessFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceImageRobustnessFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceImageRobustnessFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceImageRobustnessFeatures* toTransform);
+
+void transform_tohost_VkBufferCopy2(VkDecoderGlobalState* resourceTracker,
+                                    VkBufferCopy2* toTransform);
+
+void transform_fromhost_VkBufferCopy2(VkDecoderGlobalState* resourceTracker,
+                                      VkBufferCopy2* toTransform);
+
+void transform_tohost_VkCopyBufferInfo2(VkDecoderGlobalState* resourceTracker,
+                                        VkCopyBufferInfo2* toTransform);
+
+void transform_fromhost_VkCopyBufferInfo2(VkDecoderGlobalState* resourceTracker,
+                                          VkCopyBufferInfo2* toTransform);
+
+void transform_tohost_VkImageCopy2(VkDecoderGlobalState* resourceTracker,
+                                   VkImageCopy2* toTransform);
+
+void transform_fromhost_VkImageCopy2(VkDecoderGlobalState* resourceTracker,
+                                     VkImageCopy2* toTransform);
+
+void transform_tohost_VkCopyImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                       VkCopyImageInfo2* toTransform);
+
+void transform_fromhost_VkCopyImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                         VkCopyImageInfo2* toTransform);
+
+void transform_tohost_VkBufferImageCopy2(VkDecoderGlobalState* resourceTracker,
+                                         VkBufferImageCopy2* toTransform);
+
+void transform_fromhost_VkBufferImageCopy2(VkDecoderGlobalState* resourceTracker,
+                                           VkBufferImageCopy2* toTransform);
+
+void transform_tohost_VkCopyBufferToImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                               VkCopyBufferToImageInfo2* toTransform);
+
+void transform_fromhost_VkCopyBufferToImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                                 VkCopyBufferToImageInfo2* toTransform);
+
+void transform_tohost_VkCopyImageToBufferInfo2(VkDecoderGlobalState* resourceTracker,
+                                               VkCopyImageToBufferInfo2* toTransform);
+
+void transform_fromhost_VkCopyImageToBufferInfo2(VkDecoderGlobalState* resourceTracker,
+                                                 VkCopyImageToBufferInfo2* toTransform);
+
+void transform_tohost_VkImageBlit2(VkDecoderGlobalState* resourceTracker,
+                                   VkImageBlit2* toTransform);
+
+void transform_fromhost_VkImageBlit2(VkDecoderGlobalState* resourceTracker,
+                                     VkImageBlit2* toTransform);
+
+void transform_tohost_VkBlitImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                       VkBlitImageInfo2* toTransform);
+
+void transform_fromhost_VkBlitImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                         VkBlitImageInfo2* toTransform);
+
+void transform_tohost_VkImageResolve2(VkDecoderGlobalState* resourceTracker,
+                                      VkImageResolve2* toTransform);
+
+void transform_fromhost_VkImageResolve2(VkDecoderGlobalState* resourceTracker,
+                                        VkImageResolve2* toTransform);
+
+void transform_tohost_VkResolveImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                          VkResolveImageInfo2* toTransform);
+
+void transform_fromhost_VkResolveImageInfo2(VkDecoderGlobalState* resourceTracker,
+                                            VkResolveImageInfo2* toTransform);
+
+void transform_tohost_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceSubgroupSizeControlFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceSubgroupSizeControlFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceSubgroupSizeControlFeatures* toTransform);
+
+void transform_tohost_VkPhysicalDeviceSubgroupSizeControlProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceSubgroupSizeControlProperties* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceSubgroupSizeControlProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceSubgroupSizeControlProperties* toTransform);
+
+void transform_tohost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    VkDecoderGlobalState* resourceTracker,
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* toTransform);
+
+void transform_fromhost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo(
+    VkDecoderGlobalState* resourceTracker,
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfo* toTransform);
+
+void transform_tohost_VkPhysicalDeviceInlineUniformBlockFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceInlineUniformBlockFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceInlineUniformBlockFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceInlineUniformBlockFeatures* toTransform);
+
+void transform_tohost_VkPhysicalDeviceInlineUniformBlockProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceInlineUniformBlockProperties* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceInlineUniformBlockProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceInlineUniformBlockProperties* toTransform);
+
+void transform_tohost_VkWriteDescriptorSetInlineUniformBlock(
+    VkDecoderGlobalState* resourceTracker, VkWriteDescriptorSetInlineUniformBlock* toTransform);
+
+void transform_fromhost_VkWriteDescriptorSetInlineUniformBlock(
+    VkDecoderGlobalState* resourceTracker, VkWriteDescriptorSetInlineUniformBlock* toTransform);
+
+void transform_tohost_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    VkDecoderGlobalState* resourceTracker,
+    VkDescriptorPoolInlineUniformBlockCreateInfo* toTransform);
+
+void transform_fromhost_VkDescriptorPoolInlineUniformBlockCreateInfo(
+    VkDecoderGlobalState* resourceTracker,
+    VkDescriptorPoolInlineUniformBlockCreateInfo* toTransform);
+
+void transform_tohost_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceTextureCompressionASTCHDRFeatures* toTransform);
+
+void transform_tohost_VkRenderingAttachmentInfo(VkDecoderGlobalState* resourceTracker,
+                                                VkRenderingAttachmentInfo* toTransform);
+
+void transform_fromhost_VkRenderingAttachmentInfo(VkDecoderGlobalState* resourceTracker,
+                                                  VkRenderingAttachmentInfo* toTransform);
+
+void transform_tohost_VkRenderingInfo(VkDecoderGlobalState* resourceTracker,
+                                      VkRenderingInfo* toTransform);
+
+void transform_fromhost_VkRenderingInfo(VkDecoderGlobalState* resourceTracker,
+                                        VkRenderingInfo* toTransform);
+
+void transform_tohost_VkPipelineRenderingCreateInfo(VkDecoderGlobalState* resourceTracker,
+                                                    VkPipelineRenderingCreateInfo* toTransform);
+
+void transform_fromhost_VkPipelineRenderingCreateInfo(VkDecoderGlobalState* resourceTracker,
+                                                      VkPipelineRenderingCreateInfo* toTransform);
+
+void transform_tohost_VkPhysicalDeviceDynamicRenderingFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceDynamicRenderingFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceDynamicRenderingFeatures(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceDynamicRenderingFeatures* toTransform);
+
+void transform_tohost_VkCommandBufferInheritanceRenderingInfo(
+    VkDecoderGlobalState* resourceTracker, VkCommandBufferInheritanceRenderingInfo* toTransform);
+
+void transform_fromhost_VkCommandBufferInheritanceRenderingInfo(
+    VkDecoderGlobalState* resourceTracker, VkCommandBufferInheritanceRenderingInfo* toTransform);
+
+void transform_tohost_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderIntegerDotProductFeatures* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductFeatures(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderIntegerDotProductFeatures* toTransform);
+
+void transform_tohost_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderIntegerDotProductProperties* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderIntegerDotProductProperties* toTransform);
+
+void transform_tohost_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceTexelBufferAlignmentProperties* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentProperties(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceTexelBufferAlignmentProperties* toTransform);
+
+void transform_tohost_VkFormatProperties3(VkDecoderGlobalState* resourceTracker,
+                                          VkFormatProperties3* toTransform);
+
+void transform_fromhost_VkFormatProperties3(VkDecoderGlobalState* resourceTracker,
+                                            VkFormatProperties3* toTransform);
+
+void transform_tohost_VkPhysicalDeviceMaintenance4Features(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4Features* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMaintenance4Features(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4Features* toTransform);
+
+void transform_tohost_VkPhysicalDeviceMaintenance4Properties(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4Properties* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMaintenance4Properties(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4Properties* toTransform);
+
+void transform_tohost_VkDeviceBufferMemoryRequirements(
+    VkDecoderGlobalState* resourceTracker, VkDeviceBufferMemoryRequirements* toTransform);
+
+void transform_fromhost_VkDeviceBufferMemoryRequirements(
+    VkDecoderGlobalState* resourceTracker, VkDeviceBufferMemoryRequirements* toTransform);
+
+void transform_tohost_VkDeviceImageMemoryRequirements(VkDecoderGlobalState* resourceTracker,
+                                                      VkDeviceImageMemoryRequirements* toTransform);
+
+void transform_fromhost_VkDeviceImageMemoryRequirements(
+    VkDecoderGlobalState* resourceTracker, VkDeviceImageMemoryRequirements* toTransform);
+
+#endif
 #ifdef VK_KHR_surface
 void transform_tohost_VkSurfaceCapabilitiesKHR(VkDecoderGlobalState* resourceTracker,
                                                VkSurfaceCapabilitiesKHR* toTransform);
@@ -1627,23 +1973,31 @@ void transform_fromhost_VkWin32SurfaceCreateInfoKHR(VkDecoderGlobalState* resour
 #ifdef VK_KHR_sampler_mirror_clamp_to_edge
 #endif
 #ifdef VK_KHR_video_queue
-void transform_tohost_VkVideoQueueFamilyProperties2KHR(
-    VkDecoderGlobalState* resourceTracker, VkVideoQueueFamilyProperties2KHR* toTransform);
+void transform_tohost_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkQueueFamilyQueryResultStatusPropertiesKHR* toTransform);
+
+void transform_fromhost_VkQueueFamilyQueryResultStatusPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkQueueFamilyQueryResultStatusPropertiesKHR* toTransform);
 
-void transform_fromhost_VkVideoQueueFamilyProperties2KHR(
-    VkDecoderGlobalState* resourceTracker, VkVideoQueueFamilyProperties2KHR* toTransform);
+void transform_tohost_VkQueueFamilyVideoPropertiesKHR(VkDecoderGlobalState* resourceTracker,
+                                                      VkQueueFamilyVideoPropertiesKHR* toTransform);
 
-void transform_tohost_VkVideoProfileKHR(VkDecoderGlobalState* resourceTracker,
-                                        VkVideoProfileKHR* toTransform);
+void transform_fromhost_VkQueueFamilyVideoPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkQueueFamilyVideoPropertiesKHR* toTransform);
 
-void transform_fromhost_VkVideoProfileKHR(VkDecoderGlobalState* resourceTracker,
-                                          VkVideoProfileKHR* toTransform);
+void transform_tohost_VkVideoProfileInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                            VkVideoProfileInfoKHR* toTransform);
 
-void transform_tohost_VkVideoProfilesKHR(VkDecoderGlobalState* resourceTracker,
-                                         VkVideoProfilesKHR* toTransform);
+void transform_fromhost_VkVideoProfileInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                              VkVideoProfileInfoKHR* toTransform);
 
-void transform_fromhost_VkVideoProfilesKHR(VkDecoderGlobalState* resourceTracker,
-                                           VkVideoProfilesKHR* toTransform);
+void transform_tohost_VkVideoProfileListInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                VkVideoProfileListInfoKHR* toTransform);
+
+void transform_fromhost_VkVideoProfileListInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                  VkVideoProfileListInfoKHR* toTransform);
 
 void transform_tohost_VkVideoCapabilitiesKHR(VkDecoderGlobalState* resourceTracker,
                                              VkVideoCapabilitiesKHR* toTransform);
@@ -1663,29 +2017,29 @@ void transform_tohost_VkVideoFormatPropertiesKHR(VkDecoderGlobalState* resourceT
 void transform_fromhost_VkVideoFormatPropertiesKHR(VkDecoderGlobalState* resourceTracker,
                                                    VkVideoFormatPropertiesKHR* toTransform);
 
-void transform_tohost_VkVideoPictureResourceKHR(VkDecoderGlobalState* resourceTracker,
-                                                VkVideoPictureResourceKHR* toTransform);
+void transform_tohost_VkVideoPictureResourceInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                    VkVideoPictureResourceInfoKHR* toTransform);
 
-void transform_fromhost_VkVideoPictureResourceKHR(VkDecoderGlobalState* resourceTracker,
-                                                  VkVideoPictureResourceKHR* toTransform);
+void transform_fromhost_VkVideoPictureResourceInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoPictureResourceInfoKHR* toTransform);
 
-void transform_tohost_VkVideoReferenceSlotKHR(VkDecoderGlobalState* resourceTracker,
-                                              VkVideoReferenceSlotKHR* toTransform);
+void transform_tohost_VkVideoReferenceSlotInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                  VkVideoReferenceSlotInfoKHR* toTransform);
 
-void transform_fromhost_VkVideoReferenceSlotKHR(VkDecoderGlobalState* resourceTracker,
-                                                VkVideoReferenceSlotKHR* toTransform);
+void transform_fromhost_VkVideoReferenceSlotInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                    VkVideoReferenceSlotInfoKHR* toTransform);
 
-void transform_tohost_VkVideoGetMemoryPropertiesKHR(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoGetMemoryPropertiesKHR* toTransform);
+void transform_tohost_VkVideoSessionMemoryRequirementsKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoSessionMemoryRequirementsKHR* toTransform);
 
-void transform_fromhost_VkVideoGetMemoryPropertiesKHR(VkDecoderGlobalState* resourceTracker,
-                                                      VkVideoGetMemoryPropertiesKHR* toTransform);
+void transform_fromhost_VkVideoSessionMemoryRequirementsKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoSessionMemoryRequirementsKHR* toTransform);
 
-void transform_tohost_VkVideoBindMemoryKHR(VkDecoderGlobalState* resourceTracker,
-                                           VkVideoBindMemoryKHR* toTransform);
+void transform_tohost_VkBindVideoSessionMemoryInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                      VkBindVideoSessionMemoryInfoKHR* toTransform);
 
-void transform_fromhost_VkVideoBindMemoryKHR(VkDecoderGlobalState* resourceTracker,
-                                             VkVideoBindMemoryKHR* toTransform);
+void transform_fromhost_VkBindVideoSessionMemoryInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkBindVideoSessionMemoryInfoKHR* toTransform);
 
 void transform_tohost_VkVideoSessionCreateInfoKHR(VkDecoderGlobalState* resourceTracker,
                                                   VkVideoSessionCreateInfoKHR* toTransform);
@@ -1725,6 +2079,18 @@ void transform_fromhost_VkVideoCodingControlInfoKHR(VkDecoderGlobalState* resour
 
 #endif
 #ifdef VK_KHR_video_decode_queue
+void transform_tohost_VkVideoDecodeCapabilitiesKHR(VkDecoderGlobalState* resourceTracker,
+                                                   VkVideoDecodeCapabilitiesKHR* toTransform);
+
+void transform_fromhost_VkVideoDecodeCapabilitiesKHR(VkDecoderGlobalState* resourceTracker,
+                                                     VkVideoDecodeCapabilitiesKHR* toTransform);
+
+void transform_tohost_VkVideoDecodeUsageInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                VkVideoDecodeUsageInfoKHR* toTransform);
+
+void transform_fromhost_VkVideoDecodeUsageInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                  VkVideoDecodeUsageInfoKHR* toTransform);
+
 void transform_tohost_VkVideoDecodeInfoKHR(VkDecoderGlobalState* resourceTracker,
                                            VkVideoDecodeInfoKHR* toTransform);
 
@@ -1732,38 +2098,76 @@ void transform_fromhost_VkVideoDecodeInfoKHR(VkDecoderGlobalState* resourceTrack
                                              VkVideoDecodeInfoKHR* toTransform);
 
 #endif
-#ifdef VK_KHR_dynamic_rendering
-void transform_tohost_VkRenderingAttachmentInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                                   VkRenderingAttachmentInfoKHR* toTransform);
+#ifdef VK_KHR_video_decode_h264
+void transform_tohost_VkVideoDecodeH264ProfileInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoDecodeH264ProfileInfoKHR* toTransform);
 
-void transform_fromhost_VkRenderingAttachmentInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                                     VkRenderingAttachmentInfoKHR* toTransform);
+void transform_fromhost_VkVideoDecodeH264ProfileInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264ProfileInfoKHR* toTransform);
 
-void transform_tohost_VkRenderingInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                         VkRenderingInfoKHR* toTransform);
+void transform_tohost_VkVideoDecodeH264CapabilitiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264CapabilitiesKHR* toTransform);
 
-void transform_fromhost_VkRenderingInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                           VkRenderingInfoKHR* toTransform);
+void transform_fromhost_VkVideoDecodeH264CapabilitiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264CapabilitiesKHR* toTransform);
 
-void transform_tohost_VkPipelineRenderingCreateInfoKHR(
-    VkDecoderGlobalState* resourceTracker, VkPipelineRenderingCreateInfoKHR* toTransform);
+void transform_tohost_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkVideoDecodeH264SessionParametersAddInfoKHR* toTransform);
 
-void transform_fromhost_VkPipelineRenderingCreateInfoKHR(
-    VkDecoderGlobalState* resourceTracker, VkPipelineRenderingCreateInfoKHR* toTransform);
+void transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkVideoDecodeH264SessionParametersAddInfoKHR* toTransform);
 
-void transform_tohost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+void transform_tohost_VkVideoDecodeH264SessionParametersCreateInfoKHR(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceDynamicRenderingFeaturesKHR* toTransform);
+    VkVideoDecodeH264SessionParametersCreateInfoKHR* toTransform);
 
-void transform_fromhost_VkPhysicalDeviceDynamicRenderingFeaturesKHR(
+void transform_fromhost_VkVideoDecodeH264SessionParametersCreateInfoKHR(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceDynamicRenderingFeaturesKHR* toTransform);
+    VkVideoDecodeH264SessionParametersCreateInfoKHR* toTransform);
+
+void transform_tohost_VkVideoDecodeH264PictureInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoDecodeH264PictureInfoKHR* toTransform);
+
+void transform_fromhost_VkVideoDecodeH264PictureInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264PictureInfoKHR* toTransform);
+
+void transform_tohost_VkVideoDecodeH264DpbSlotInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoDecodeH264DpbSlotInfoKHR* toTransform);
+
+void transform_fromhost_VkVideoDecodeH264DpbSlotInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264DpbSlotInfoKHR* toTransform);
+
+#endif
+#ifdef VK_KHR_dynamic_rendering
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkRenderingInfo, transform_tohost_VkRenderingInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkRenderingInfo, transform_fromhost_VkRenderingInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkRenderingAttachmentInfo,
+                      transform_tohost_VkRenderingAttachmentInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkRenderingAttachmentInfo,
+                      transform_fromhost_VkRenderingAttachmentInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineRenderingCreateInfo,
+                      transform_tohost_VkPipelineRenderingCreateInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineRenderingCreateInfo,
+                      transform_fromhost_VkPipelineRenderingCreateInfoKHR)
+
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceDynamicRenderingFeatures,
+                      transform_tohost_VkPhysicalDeviceDynamicRenderingFeaturesKHR)
+
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceDynamicRenderingFeatures,
+                      transform_fromhost_VkPhysicalDeviceDynamicRenderingFeaturesKHR)
 
-void transform_tohost_VkCommandBufferInheritanceRenderingInfoKHR(
-    VkDecoderGlobalState* resourceTracker, VkCommandBufferInheritanceRenderingInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkCommandBufferInheritanceRenderingInfo,
+                      transform_tohost_VkCommandBufferInheritanceRenderingInfoKHR)
 
-void transform_fromhost_VkCommandBufferInheritanceRenderingInfoKHR(
-    VkDecoderGlobalState* resourceTracker, VkCommandBufferInheritanceRenderingInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkCommandBufferInheritanceRenderingInfo,
+                      transform_fromhost_VkCommandBufferInheritanceRenderingInfoKHR)
 
 void transform_tohost_VkRenderingFragmentShadingRateAttachmentInfoKHR(
     VkDecoderGlobalState* resourceTracker,
@@ -2636,6 +3040,70 @@ void transform_fromhost_VkPhysicalDeviceShaderClockFeaturesKHR(
     VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderClockFeaturesKHR* toTransform);
 
 #endif
+#ifdef VK_KHR_video_decode_h265
+void transform_tohost_VkVideoDecodeH265ProfileInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoDecodeH265ProfileInfoKHR* toTransform);
+
+void transform_fromhost_VkVideoDecodeH265ProfileInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265ProfileInfoKHR* toTransform);
+
+void transform_tohost_VkVideoDecodeH265CapabilitiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265CapabilitiesKHR* toTransform);
+
+void transform_fromhost_VkVideoDecodeH265CapabilitiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265CapabilitiesKHR* toTransform);
+
+void transform_tohost_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkVideoDecodeH265SessionParametersAddInfoKHR* toTransform);
+
+void transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkVideoDecodeH265SessionParametersAddInfoKHR* toTransform);
+
+void transform_tohost_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkVideoDecodeH265SessionParametersCreateInfoKHR* toTransform);
+
+void transform_fromhost_VkVideoDecodeH265SessionParametersCreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkVideoDecodeH265SessionParametersCreateInfoKHR* toTransform);
+
+void transform_tohost_VkVideoDecodeH265PictureInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoDecodeH265PictureInfoKHR* toTransform);
+
+void transform_fromhost_VkVideoDecodeH265PictureInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265PictureInfoKHR* toTransform);
+
+void transform_tohost_VkVideoDecodeH265DpbSlotInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoDecodeH265DpbSlotInfoKHR* toTransform);
+
+void transform_fromhost_VkVideoDecodeH265DpbSlotInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265DpbSlotInfoKHR* toTransform);
+
+#endif
+#ifdef VK_KHR_global_priority
+void transform_tohost_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfoKHR* toTransform);
+
+void transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfoKHR* toTransform);
+
+void transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR* toTransform);
+
+void transform_tohost_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkQueueFamilyGlobalPriorityPropertiesKHR* toTransform);
+
+void transform_fromhost_VkQueueFamilyGlobalPriorityPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker, VkQueueFamilyGlobalPriorityPropertiesKHR* toTransform);
+
+#endif
 #ifdef VK_KHR_driver_properties
 DEFINE_ALIAS_FUNCTION(transform_tohost_VkConformanceVersion,
                       transform_tohost_VkConformanceVersionKHR)
@@ -2720,13 +3188,11 @@ DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceVulkanMemoryModelFeatur
 
 #endif
 #ifdef VK_KHR_shader_terminate_invocation
-void transform_tohost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderTerminateInvocationFeatures,
+                      transform_tohost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)
 
-void transform_fromhost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderTerminateInvocationFeatures,
+                      transform_fromhost_VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR)
 
 #endif
 #ifdef VK_KHR_fragment_shading_rate
@@ -2895,22 +3361,32 @@ void transform_fromhost_VkPipelineExecutableInternalRepresentationKHR(
     VkPipelineExecutableInternalRepresentationKHR* toTransform);
 
 #endif
+#ifdef VK_KHR_map_memory2
+void transform_tohost_VkMemoryMapInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                         VkMemoryMapInfoKHR* toTransform);
+
+void transform_fromhost_VkMemoryMapInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                           VkMemoryMapInfoKHR* toTransform);
+
+void transform_tohost_VkMemoryUnmapInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                           VkMemoryUnmapInfoKHR* toTransform);
+
+void transform_fromhost_VkMemoryUnmapInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                             VkMemoryUnmapInfoKHR* toTransform);
+
+#endif
 #ifdef VK_KHR_shader_integer_dot_product
-void transform_tohost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderIntegerDotProductFeatures,
+                      transform_tohost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR)
 
-void transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductFeatures,
+                      transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR)
 
-void transform_tohost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderIntegerDotProductProperties,
+                      transform_tohost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)
 
-void transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductProperties,
+                      transform_fromhost_VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR)
 
 #endif
 #ifdef VK_KHR_pipeline_library
@@ -2944,6 +3420,32 @@ void transform_tohost_VkVideoEncodeInfoKHR(VkDecoderGlobalState* resourceTracker
 void transform_fromhost_VkVideoEncodeInfoKHR(VkDecoderGlobalState* resourceTracker,
                                              VkVideoEncodeInfoKHR* toTransform);
 
+void transform_tohost_VkVideoEncodeCapabilitiesKHR(VkDecoderGlobalState* resourceTracker,
+                                                   VkVideoEncodeCapabilitiesKHR* toTransform);
+
+void transform_fromhost_VkVideoEncodeCapabilitiesKHR(VkDecoderGlobalState* resourceTracker,
+                                                     VkVideoEncodeCapabilitiesKHR* toTransform);
+
+void transform_tohost_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* toTransform);
+
+void transform_fromhost_VkQueryPoolVideoEncodeFeedbackCreateInfoKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkQueryPoolVideoEncodeFeedbackCreateInfoKHR* toTransform);
+
+void transform_tohost_VkVideoEncodeUsageInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                VkVideoEncodeUsageInfoKHR* toTransform);
+
+void transform_fromhost_VkVideoEncodeUsageInfoKHR(VkDecoderGlobalState* resourceTracker,
+                                                  VkVideoEncodeUsageInfoKHR* toTransform);
+
+void transform_tohost_VkVideoEncodeRateControlLayerInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeRateControlLayerInfoKHR* toTransform);
+
+void transform_fromhost_VkVideoEncodeRateControlLayerInfoKHR(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeRateControlLayerInfoKHR* toTransform);
+
 void transform_tohost_VkVideoEncodeRateControlInfoKHR(VkDecoderGlobalState* resourceTracker,
                                                       VkVideoEncodeRateControlInfoKHR* toTransform);
 
@@ -2952,55 +3454,47 @@ void transform_fromhost_VkVideoEncodeRateControlInfoKHR(
 
 #endif
 #ifdef VK_KHR_synchronization2
-void transform_tohost_VkMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracker,
-                                          VkMemoryBarrier2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkMemoryBarrier2, transform_tohost_VkMemoryBarrier2KHR)
 
-void transform_fromhost_VkMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracker,
-                                            VkMemoryBarrier2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMemoryBarrier2, transform_fromhost_VkMemoryBarrier2KHR)
 
-void transform_tohost_VkBufferMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracker,
-                                                VkBufferMemoryBarrier2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBufferMemoryBarrier2,
+                      transform_tohost_VkBufferMemoryBarrier2KHR)
 
-void transform_fromhost_VkBufferMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracker,
-                                                  VkBufferMemoryBarrier2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBufferMemoryBarrier2,
+                      transform_fromhost_VkBufferMemoryBarrier2KHR)
 
-void transform_tohost_VkImageMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracker,
-                                               VkImageMemoryBarrier2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageMemoryBarrier2,
+                      transform_tohost_VkImageMemoryBarrier2KHR)
 
-void transform_fromhost_VkImageMemoryBarrier2KHR(VkDecoderGlobalState* resourceTracker,
-                                                 VkImageMemoryBarrier2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageMemoryBarrier2,
+                      transform_fromhost_VkImageMemoryBarrier2KHR)
 
-void transform_tohost_VkDependencyInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                          VkDependencyInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDependencyInfo, transform_tohost_VkDependencyInfoKHR)
 
-void transform_fromhost_VkDependencyInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                            VkDependencyInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDependencyInfo, transform_fromhost_VkDependencyInfoKHR)
 
-void transform_tohost_VkSemaphoreSubmitInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                               VkSemaphoreSubmitInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSubmitInfo2, transform_tohost_VkSubmitInfo2KHR)
 
-void transform_fromhost_VkSemaphoreSubmitInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                                 VkSemaphoreSubmitInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSubmitInfo2, transform_fromhost_VkSubmitInfo2KHR)
 
-void transform_tohost_VkCommandBufferSubmitInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                                   VkCommandBufferSubmitInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkSemaphoreSubmitInfo,
+                      transform_tohost_VkSemaphoreSubmitInfoKHR)
 
-void transform_fromhost_VkCommandBufferSubmitInfoKHR(VkDecoderGlobalState* resourceTracker,
-                                                     VkCommandBufferSubmitInfoKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkSemaphoreSubmitInfo,
+                      transform_fromhost_VkSemaphoreSubmitInfoKHR)
 
-void transform_tohost_VkSubmitInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                       VkSubmitInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkCommandBufferSubmitInfo,
+                      transform_tohost_VkCommandBufferSubmitInfoKHR)
 
-void transform_fromhost_VkSubmitInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                         VkSubmitInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkCommandBufferSubmitInfo,
+                      transform_fromhost_VkCommandBufferSubmitInfoKHR)
 
-void transform_tohost_VkPhysicalDeviceSynchronization2FeaturesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceSynchronization2FeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceSynchronization2Features,
+                      transform_tohost_VkPhysicalDeviceSynchronization2FeaturesKHR)
 
-void transform_fromhost_VkPhysicalDeviceSynchronization2FeaturesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceSynchronization2FeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceSynchronization2Features,
+                      transform_fromhost_VkPhysicalDeviceSynchronization2FeaturesKHR)
 
 void transform_tohost_VkQueueFamilyCheckpointProperties2NV(
     VkDecoderGlobalState* resourceTracker, VkQueueFamilyCheckpointProperties2NV* toTransform);
@@ -3015,6 +3509,24 @@ void transform_fromhost_VkCheckpointData2NV(VkDecoderGlobalState* resourceTracke
                                             VkCheckpointData2NV* toTransform);
 
 #endif
+#ifdef VK_KHR_fragment_shader_barycentric
+void transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR* toTransform);
+
+void transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR* toTransform);
+
+#endif
 #ifdef VK_KHR_shader_subgroup_uniform_control_flow
 void transform_tohost_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR(
     VkDecoderGlobalState* resourceTracker,
@@ -3026,13 +3538,11 @@ void transform_fromhost_VkPhysicalDeviceShaderSubgroupUniformControlFlowFeatures
 
 #endif
 #ifdef VK_KHR_zero_initialize_workgroup_memory
-void transform_tohost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
+                      transform_tohost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR)
 
-void transform_fromhost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures,
+                      transform_fromhost_VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR)
 
 #endif
 #ifdef VK_KHR_workgroup_memory_explicit_layout
@@ -3046,114 +3556,145 @@ void transform_fromhost_VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
 
 #endif
 #ifdef VK_KHR_copy_commands2
-void transform_tohost_VkBufferCopy2KHR(VkDecoderGlobalState* resourceTracker,
-                                       VkBufferCopy2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkCopyBufferInfo2, transform_tohost_VkCopyBufferInfo2KHR)
 
-void transform_fromhost_VkBufferCopy2KHR(VkDecoderGlobalState* resourceTracker,
-                                         VkBufferCopy2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkCopyBufferInfo2, transform_fromhost_VkCopyBufferInfo2KHR)
 
-void transform_tohost_VkCopyBufferInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                           VkCopyBufferInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkCopyImageInfo2, transform_tohost_VkCopyImageInfo2KHR)
 
-void transform_fromhost_VkCopyBufferInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                             VkCopyBufferInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkCopyImageInfo2, transform_fromhost_VkCopyImageInfo2KHR)
 
-void transform_tohost_VkImageCopy2KHR(VkDecoderGlobalState* resourceTracker,
-                                      VkImageCopy2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkCopyBufferToImageInfo2,
+                      transform_tohost_VkCopyBufferToImageInfo2KHR)
 
-void transform_fromhost_VkImageCopy2KHR(VkDecoderGlobalState* resourceTracker,
-                                        VkImageCopy2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkCopyBufferToImageInfo2,
+                      transform_fromhost_VkCopyBufferToImageInfo2KHR)
 
-void transform_tohost_VkCopyImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                          VkCopyImageInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkCopyImageToBufferInfo2,
+                      transform_tohost_VkCopyImageToBufferInfo2KHR)
 
-void transform_fromhost_VkCopyImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                            VkCopyImageInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkCopyImageToBufferInfo2,
+                      transform_fromhost_VkCopyImageToBufferInfo2KHR)
 
-void transform_tohost_VkBufferImageCopy2KHR(VkDecoderGlobalState* resourceTracker,
-                                            VkBufferImageCopy2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBlitImageInfo2, transform_tohost_VkBlitImageInfo2KHR)
 
-void transform_fromhost_VkBufferImageCopy2KHR(VkDecoderGlobalState* resourceTracker,
-                                              VkBufferImageCopy2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBlitImageInfo2, transform_fromhost_VkBlitImageInfo2KHR)
 
-void transform_tohost_VkCopyBufferToImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                                  VkCopyBufferToImageInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkResolveImageInfo2, transform_tohost_VkResolveImageInfo2KHR)
 
-void transform_fromhost_VkCopyBufferToImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                                    VkCopyBufferToImageInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkResolveImageInfo2,
+                      transform_fromhost_VkResolveImageInfo2KHR)
 
-void transform_tohost_VkCopyImageToBufferInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                                  VkCopyImageToBufferInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBufferCopy2, transform_tohost_VkBufferCopy2KHR)
 
-void transform_fromhost_VkCopyImageToBufferInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                                    VkCopyImageToBufferInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBufferCopy2, transform_fromhost_VkBufferCopy2KHR)
 
-void transform_tohost_VkImageBlit2KHR(VkDecoderGlobalState* resourceTracker,
-                                      VkImageBlit2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageCopy2, transform_tohost_VkImageCopy2KHR)
 
-void transform_fromhost_VkImageBlit2KHR(VkDecoderGlobalState* resourceTracker,
-                                        VkImageBlit2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageCopy2, transform_fromhost_VkImageCopy2KHR)
 
-void transform_tohost_VkBlitImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                          VkBlitImageInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageBlit2, transform_tohost_VkImageBlit2KHR)
 
-void transform_fromhost_VkBlitImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                            VkBlitImageInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageBlit2, transform_fromhost_VkImageBlit2KHR)
 
-void transform_tohost_VkImageResolve2KHR(VkDecoderGlobalState* resourceTracker,
-                                         VkImageResolve2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkBufferImageCopy2, transform_tohost_VkBufferImageCopy2KHR)
 
-void transform_fromhost_VkImageResolve2KHR(VkDecoderGlobalState* resourceTracker,
-                                           VkImageResolve2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkBufferImageCopy2,
+                      transform_fromhost_VkBufferImageCopy2KHR)
 
-void transform_tohost_VkResolveImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                             VkResolveImageInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkImageResolve2, transform_tohost_VkImageResolve2KHR)
 
-void transform_fromhost_VkResolveImageInfo2KHR(VkDecoderGlobalState* resourceTracker,
-                                               VkResolveImageInfo2KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkImageResolve2, transform_fromhost_VkImageResolve2KHR)
 
 #endif
 #ifdef VK_KHR_format_feature_flags2
-void transform_tohost_VkFormatProperties3KHR(VkDecoderGlobalState* resourceTracker,
-                                             VkFormatProperties3KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkFormatProperties3, transform_tohost_VkFormatProperties3KHR)
 
-void transform_fromhost_VkFormatProperties3KHR(VkDecoderGlobalState* resourceTracker,
-                                               VkFormatProperties3KHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkFormatProperties3,
+                      transform_fromhost_VkFormatProperties3KHR)
 
 #endif
+#ifdef VK_KHR_ray_tracing_maintenance1
+void transform_tohost_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR* toTransform);
+
+void transform_tohost_VkTraceRaysIndirectCommand2KHR(VkDecoderGlobalState* resourceTracker,
+                                                     VkTraceRaysIndirectCommand2KHR* toTransform);
+
+void transform_fromhost_VkTraceRaysIndirectCommand2KHR(VkDecoderGlobalState* resourceTracker,
+                                                       VkTraceRaysIndirectCommand2KHR* toTransform);
+
+#endif
+#ifdef VK_KHR_portability_enumeration
+#endif
 #ifdef VK_KHR_maintenance4
-void transform_tohost_VkPhysicalDeviceMaintenance4FeaturesKHR(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4FeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceMaintenance4Features,
+                      transform_tohost_VkPhysicalDeviceMaintenance4FeaturesKHR)
 
-void transform_fromhost_VkPhysicalDeviceMaintenance4FeaturesKHR(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4FeaturesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceMaintenance4Features,
+                      transform_fromhost_VkPhysicalDeviceMaintenance4FeaturesKHR)
 
-void transform_tohost_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4PropertiesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceMaintenance4Properties,
+                      transform_tohost_VkPhysicalDeviceMaintenance4PropertiesKHR)
 
-void transform_fromhost_VkPhysicalDeviceMaintenance4PropertiesKHR(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMaintenance4PropertiesKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceMaintenance4Properties,
+                      transform_fromhost_VkPhysicalDeviceMaintenance4PropertiesKHR)
 
-void transform_tohost_VkDeviceBufferMemoryRequirementsKHR(
-    VkDecoderGlobalState* resourceTracker, VkDeviceBufferMemoryRequirementsKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceBufferMemoryRequirements,
+                      transform_tohost_VkDeviceBufferMemoryRequirementsKHR)
 
-void transform_fromhost_VkDeviceBufferMemoryRequirementsKHR(
-    VkDecoderGlobalState* resourceTracker, VkDeviceBufferMemoryRequirementsKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceBufferMemoryRequirements,
+                      transform_fromhost_VkDeviceBufferMemoryRequirementsKHR)
 
-void transform_tohost_VkDeviceImageMemoryRequirementsKHR(
-    VkDecoderGlobalState* resourceTracker, VkDeviceImageMemoryRequirementsKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceImageMemoryRequirements,
+                      transform_tohost_VkDeviceImageMemoryRequirementsKHR)
 
-void transform_fromhost_VkDeviceImageMemoryRequirementsKHR(
-    VkDecoderGlobalState* resourceTracker, VkDeviceImageMemoryRequirementsKHR* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceImageMemoryRequirements,
+                      transform_fromhost_VkDeviceImageMemoryRequirementsKHR)
+
+#endif
+#ifdef VK_KHR_ray_tracing_position_fetch
+void transform_tohost_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR* toTransform);
 
 #endif
 #ifdef VK_ANDROID_native_buffer
+void transform_tohost_VkNativeBufferUsage2ANDROID(VkDecoderGlobalState* resourceTracker,
+                                                  VkNativeBufferUsage2ANDROID* toTransform);
+
+void transform_fromhost_VkNativeBufferUsage2ANDROID(VkDecoderGlobalState* resourceTracker,
+                                                    VkNativeBufferUsage2ANDROID* toTransform);
+
 void transform_tohost_VkNativeBufferANDROID(VkDecoderGlobalState* resourceTracker,
                                             VkNativeBufferANDROID* toTransform);
 
 void transform_fromhost_VkNativeBufferANDROID(VkDecoderGlobalState* resourceTracker,
                                               VkNativeBufferANDROID* toTransform);
 
+void transform_tohost_VkSwapchainImageCreateInfoANDROID(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainImageCreateInfoANDROID* toTransform);
+
+void transform_fromhost_VkSwapchainImageCreateInfoANDROID(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainImageCreateInfoANDROID* toTransform);
+
+void transform_tohost_VkPhysicalDevicePresentationPropertiesANDROID(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePresentationPropertiesANDROID* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePresentationPropertiesANDROID(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePresentationPropertiesANDROID* toTransform);
+
 #endif
 #ifdef VK_EXT_debug_report
 void transform_tohost_VkDebugReportCallbackCreateInfoEXT(
@@ -3300,12 +3841,6 @@ void transform_tohost_VkVideoEncodeH264CapabilitiesEXT(
 void transform_fromhost_VkVideoEncodeH264CapabilitiesEXT(
     VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264CapabilitiesEXT* toTransform);
 
-void transform_tohost_VkVideoEncodeH264SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264SessionCreateInfoEXT* toTransform);
-
-void transform_fromhost_VkVideoEncodeH264SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264SessionCreateInfoEXT* toTransform);
-
 void transform_tohost_VkVideoEncodeH264SessionParametersAddInfoEXT(
     VkDecoderGlobalState* resourceTracker,
     VkVideoEncodeH264SessionParametersAddInfoEXT* toTransform);
@@ -3322,35 +3857,53 @@ void transform_fromhost_VkVideoEncodeH264SessionParametersCreateInfoEXT(
     VkDecoderGlobalState* resourceTracker,
     VkVideoEncodeH264SessionParametersCreateInfoEXT* toTransform);
 
+void transform_tohost_VkVideoEncodeH264NaluSliceInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264NaluSliceInfoEXT* toTransform);
+
+void transform_fromhost_VkVideoEncodeH264NaluSliceInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264NaluSliceInfoEXT* toTransform);
+
+void transform_tohost_VkVideoEncodeH264VclFrameInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264VclFrameInfoEXT* toTransform);
+
+void transform_fromhost_VkVideoEncodeH264VclFrameInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264VclFrameInfoEXT* toTransform);
+
 void transform_tohost_VkVideoEncodeH264DpbSlotInfoEXT(VkDecoderGlobalState* resourceTracker,
                                                       VkVideoEncodeH264DpbSlotInfoEXT* toTransform);
 
 void transform_fromhost_VkVideoEncodeH264DpbSlotInfoEXT(
     VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264DpbSlotInfoEXT* toTransform);
 
-void transform_tohost_VkVideoEncodeH264NaluSliceEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoEncodeH264NaluSliceEXT* toTransform);
+void transform_tohost_VkVideoEncodeH264ProfileInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoEncodeH264ProfileInfoEXT* toTransform);
 
-void transform_fromhost_VkVideoEncodeH264NaluSliceEXT(VkDecoderGlobalState* resourceTracker,
-                                                      VkVideoEncodeH264NaluSliceEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH264ProfileInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264ProfileInfoEXT* toTransform);
 
-void transform_tohost_VkVideoEncodeH264VclFrameInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264VclFrameInfoEXT* toTransform);
+void transform_tohost_VkVideoEncodeH264RateControlInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264RateControlInfoEXT* toTransform);
 
-void transform_fromhost_VkVideoEncodeH264VclFrameInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264VclFrameInfoEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH264RateControlInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264RateControlInfoEXT* toTransform);
+
+void transform_tohost_VkVideoEncodeH264QpEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkVideoEncodeH264QpEXT* toTransform);
 
-void transform_tohost_VkVideoEncodeH264EmitPictureParametersEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264EmitPictureParametersEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH264QpEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkVideoEncodeH264QpEXT* toTransform);
 
-void transform_fromhost_VkVideoEncodeH264EmitPictureParametersEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264EmitPictureParametersEXT* toTransform);
+void transform_tohost_VkVideoEncodeH264FrameSizeEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkVideoEncodeH264FrameSizeEXT* toTransform);
 
-void transform_tohost_VkVideoEncodeH264ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                  VkVideoEncodeH264ProfileEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH264FrameSizeEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoEncodeH264FrameSizeEXT* toTransform);
 
-void transform_fromhost_VkVideoEncodeH264ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoEncodeH264ProfileEXT* toTransform);
+void transform_tohost_VkVideoEncodeH264RateControlLayerInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264RateControlLayerInfoEXT* toTransform);
+
+void transform_fromhost_VkVideoEncodeH264RateControlLayerInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH264RateControlLayerInfoEXT* toTransform);
 
 #endif
 #ifdef VK_EXT_video_encode_h265
@@ -3360,12 +3913,6 @@ void transform_tohost_VkVideoEncodeH265CapabilitiesEXT(
 void transform_fromhost_VkVideoEncodeH265CapabilitiesEXT(
     VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265CapabilitiesEXT* toTransform);
 
-void transform_tohost_VkVideoEncodeH265SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265SessionCreateInfoEXT* toTransform);
-
-void transform_fromhost_VkVideoEncodeH265SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265SessionCreateInfoEXT* toTransform);
-
 void transform_tohost_VkVideoEncodeH265SessionParametersAddInfoEXT(
     VkDecoderGlobalState* resourceTracker,
     VkVideoEncodeH265SessionParametersAddInfoEXT* toTransform);
@@ -3382,23 +3929,11 @@ void transform_fromhost_VkVideoEncodeH265SessionParametersCreateInfoEXT(
     VkDecoderGlobalState* resourceTracker,
     VkVideoEncodeH265SessionParametersCreateInfoEXT* toTransform);
 
-void transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(VkDecoderGlobalState* resourceTracker,
-                                                      VkVideoEncodeH265DpbSlotInfoEXT* toTransform);
-
-void transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265DpbSlotInfoEXT* toTransform);
-
-void transform_tohost_VkVideoEncodeH265ReferenceListsEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265ReferenceListsEXT* toTransform);
+void transform_tohost_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265NaluSliceSegmentInfoEXT* toTransform);
 
-void transform_fromhost_VkVideoEncodeH265ReferenceListsEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265ReferenceListsEXT* toTransform);
-
-void transform_tohost_VkVideoEncodeH265NaluSliceEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoEncodeH265NaluSliceEXT* toTransform);
-
-void transform_fromhost_VkVideoEncodeH265NaluSliceEXT(VkDecoderGlobalState* resourceTracker,
-                                                      VkVideoEncodeH265NaluSliceEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH265NaluSliceSegmentInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265NaluSliceSegmentInfoEXT* toTransform);
 
 void transform_tohost_VkVideoEncodeH265VclFrameInfoEXT(
     VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265VclFrameInfoEXT* toTransform);
@@ -3406,71 +3941,41 @@ void transform_tohost_VkVideoEncodeH265VclFrameInfoEXT(
 void transform_fromhost_VkVideoEncodeH265VclFrameInfoEXT(
     VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265VclFrameInfoEXT* toTransform);
 
-void transform_tohost_VkVideoEncodeH265EmitPictureParametersEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265EmitPictureParametersEXT* toTransform);
-
-void transform_fromhost_VkVideoEncodeH265EmitPictureParametersEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265EmitPictureParametersEXT* toTransform);
-
-void transform_tohost_VkVideoEncodeH265ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                  VkVideoEncodeH265ProfileEXT* toTransform);
-
-void transform_fromhost_VkVideoEncodeH265ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoEncodeH265ProfileEXT* toTransform);
-
-#endif
-#ifdef VK_EXT_video_decode_h264
-void transform_tohost_VkVideoDecodeH264ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                  VkVideoDecodeH264ProfileEXT* toTransform);
-
-void transform_fromhost_VkVideoDecodeH264ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoDecodeH264ProfileEXT* toTransform);
-
-void transform_tohost_VkVideoDecodeH264CapabilitiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264CapabilitiesEXT* toTransform);
-
-void transform_fromhost_VkVideoDecodeH264CapabilitiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264CapabilitiesEXT* toTransform);
-
-void transform_tohost_VkVideoDecodeH264SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264SessionCreateInfoEXT* toTransform);
+void transform_tohost_VkVideoEncodeH265DpbSlotInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoEncodeH265DpbSlotInfoEXT* toTransform);
 
-void transform_fromhost_VkVideoDecodeH264SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264SessionCreateInfoEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH265DpbSlotInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265DpbSlotInfoEXT* toTransform);
 
-void transform_tohost_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH264SessionParametersAddInfoEXT* toTransform);
+void transform_tohost_VkVideoEncodeH265ProfileInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoEncodeH265ProfileInfoEXT* toTransform);
 
-void transform_fromhost_VkVideoDecodeH264SessionParametersAddInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH264SessionParametersAddInfoEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH265ProfileInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265ProfileInfoEXT* toTransform);
 
-void transform_tohost_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH264SessionParametersCreateInfoEXT* toTransform);
+void transform_tohost_VkVideoEncodeH265RateControlInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265RateControlInfoEXT* toTransform);
 
-void transform_fromhost_VkVideoDecodeH264SessionParametersCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH264SessionParametersCreateInfoEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH265RateControlInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265RateControlInfoEXT* toTransform);
 
-void transform_tohost_VkVideoDecodeH264PictureInfoEXT(VkDecoderGlobalState* resourceTracker,
-                                                      VkVideoDecodeH264PictureInfoEXT* toTransform);
+void transform_tohost_VkVideoEncodeH265QpEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkVideoEncodeH265QpEXT* toTransform);
 
-void transform_fromhost_VkVideoDecodeH264PictureInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264PictureInfoEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH265QpEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkVideoEncodeH265QpEXT* toTransform);
 
-void transform_tohost_VkVideoDecodeH264MvcEXT(VkDecoderGlobalState* resourceTracker,
-                                              VkVideoDecodeH264MvcEXT* toTransform);
+void transform_tohost_VkVideoEncodeH265FrameSizeEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkVideoEncodeH265FrameSizeEXT* toTransform);
 
-void transform_fromhost_VkVideoDecodeH264MvcEXT(VkDecoderGlobalState* resourceTracker,
-                                                VkVideoDecodeH264MvcEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH265FrameSizeEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkVideoEncodeH265FrameSizeEXT* toTransform);
 
-void transform_tohost_VkVideoDecodeH264DpbSlotInfoEXT(VkDecoderGlobalState* resourceTracker,
-                                                      VkVideoDecodeH264DpbSlotInfoEXT* toTransform);
+void transform_tohost_VkVideoEncodeH265RateControlLayerInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265RateControlLayerInfoEXT* toTransform);
 
-void transform_fromhost_VkVideoDecodeH264DpbSlotInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH264DpbSlotInfoEXT* toTransform);
+void transform_fromhost_VkVideoEncodeH265RateControlLayerInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkVideoEncodeH265RateControlLayerInfoEXT* toTransform);
 
 #endif
 #ifdef VK_AMD_texture_gather_bias_lod
@@ -3582,13 +4087,11 @@ void transform_fromhost_VkViSurfaceCreateInfoNN(VkDecoderGlobalState* resourceTr
 #ifdef VK_EXT_shader_subgroup_vote
 #endif
 #ifdef VK_EXT_texture_compression_astc_hdr
-void transform_tohost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceTextureCompressionASTCHDRFeatures,
+                      transform_tohost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
 
-void transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeatures,
+                      transform_fromhost_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT)
 
 #endif
 #ifdef VK_EXT_astc_decode_mode
@@ -3605,6 +4108,30 @@ void transform_fromhost_VkPhysicalDeviceASTCDecodeFeaturesEXT(
     VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceASTCDecodeFeaturesEXT* toTransform);
 
 #endif
+#ifdef VK_EXT_pipeline_robustness
+void transform_tohost_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePipelineRobustnessFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineRobustnessFeaturesEXT* toTransform);
+
+void transform_tohost_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePipelineRobustnessPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineRobustnessPropertiesEXT* toTransform);
+
+void transform_tohost_VkPipelineRobustnessCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkPipelineRobustnessCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkPipelineRobustnessCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkPipelineRobustnessCreateInfoEXT* toTransform);
+
+#endif
 #ifdef VK_EXT_conditional_rendering
 void transform_tohost_VkConditionalRenderingBeginInfoEXT(
     VkDecoderGlobalState* resourceTracker, VkConditionalRenderingBeginInfoEXT* toTransform);
@@ -3823,8 +4350,6 @@ void transform_fromhost_VkMacOSSurfaceCreateInfoMVK(VkDecoderGlobalState* resour
                                                     VkMacOSSurfaceCreateInfoMVK* toTransform);
 
 #endif
-#ifdef VK_MVK_moltenvk
-#endif
 #ifdef VK_EXT_external_memory_dma_buf
 #endif
 #ifdef VK_EXT_queue_family_foreign
@@ -3932,35 +4457,29 @@ DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceSamplerFilterMinmaxProp
 #ifdef VK_AMD_shader_fragment_mask
 #endif
 #ifdef VK_EXT_inline_uniform_block
-void transform_tohost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceInlineUniformBlockFeatures,
+                      transform_tohost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT)
 
-void transform_fromhost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceInlineUniformBlockFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceInlineUniformBlockFeatures,
+                      transform_fromhost_VkPhysicalDeviceInlineUniformBlockFeaturesEXT)
 
-void transform_tohost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceInlineUniformBlockProperties,
+                      transform_tohost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT)
 
-void transform_fromhost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceInlineUniformBlockPropertiesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceInlineUniformBlockProperties,
+                      transform_fromhost_VkPhysicalDeviceInlineUniformBlockPropertiesEXT)
 
-void transform_tohost_VkWriteDescriptorSetInlineUniformBlockEXT(
-    VkDecoderGlobalState* resourceTracker, VkWriteDescriptorSetInlineUniformBlockEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkWriteDescriptorSetInlineUniformBlock,
+                      transform_tohost_VkWriteDescriptorSetInlineUniformBlockEXT)
 
-void transform_fromhost_VkWriteDescriptorSetInlineUniformBlockEXT(
-    VkDecoderGlobalState* resourceTracker, VkWriteDescriptorSetInlineUniformBlockEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkWriteDescriptorSetInlineUniformBlock,
+                      transform_fromhost_VkWriteDescriptorSetInlineUniformBlockEXT)
 
-void transform_tohost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDescriptorPoolInlineUniformBlockCreateInfo,
+                      transform_tohost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)
 
-void transform_fromhost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkDescriptorPoolInlineUniformBlockCreateInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDescriptorPoolInlineUniformBlockCreateInfo,
+                      transform_fromhost_VkDescriptorPoolInlineUniformBlockCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_shader_stencil_export
@@ -4385,11 +4904,11 @@ void transform_fromhost_VkFilterCubicImageViewImageFormatPropertiesEXT(
 #ifdef VK_QCOM_render_pass_shader_resolve
 #endif
 #ifdef VK_EXT_global_priority
-void transform_tohost_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDeviceQueueGlobalPriorityCreateInfoKHR,
+                      transform_tohost_VkDeviceQueueGlobalPriorityCreateInfoEXT)
 
-void transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkDeviceQueueGlobalPriorityCreateInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfoKHR,
+                      transform_fromhost_VkDeviceQueueGlobalPriorityCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_external_memory_host
@@ -4440,54 +4959,6 @@ void transform_fromhost_VkPhysicalDeviceShaderCorePropertiesAMD(
     VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderCorePropertiesAMD* toTransform);
 
 #endif
-#ifdef VK_EXT_video_decode_h265
-void transform_tohost_VkVideoDecodeH265ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                  VkVideoDecodeH265ProfileEXT* toTransform);
-
-void transform_fromhost_VkVideoDecodeH265ProfileEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkVideoDecodeH265ProfileEXT* toTransform);
-
-void transform_tohost_VkVideoDecodeH265CapabilitiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265CapabilitiesEXT* toTransform);
-
-void transform_fromhost_VkVideoDecodeH265CapabilitiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265CapabilitiesEXT* toTransform);
-
-void transform_tohost_VkVideoDecodeH265SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265SessionCreateInfoEXT* toTransform);
-
-void transform_fromhost_VkVideoDecodeH265SessionCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265SessionCreateInfoEXT* toTransform);
-
-void transform_tohost_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH265SessionParametersAddInfoEXT* toTransform);
-
-void transform_fromhost_VkVideoDecodeH265SessionParametersAddInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH265SessionParametersAddInfoEXT* toTransform);
-
-void transform_tohost_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH265SessionParametersCreateInfoEXT* toTransform);
-
-void transform_fromhost_VkVideoDecodeH265SessionParametersCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkVideoDecodeH265SessionParametersCreateInfoEXT* toTransform);
-
-void transform_tohost_VkVideoDecodeH265PictureInfoEXT(VkDecoderGlobalState* resourceTracker,
-                                                      VkVideoDecodeH265PictureInfoEXT* toTransform);
-
-void transform_fromhost_VkVideoDecodeH265PictureInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265PictureInfoEXT* toTransform);
-
-void transform_tohost_VkVideoDecodeH265DpbSlotInfoEXT(VkDecoderGlobalState* resourceTracker,
-                                                      VkVideoDecodeH265DpbSlotInfoEXT* toTransform);
-
-void transform_fromhost_VkVideoDecodeH265DpbSlotInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkVideoDecodeH265DpbSlotInfoEXT* toTransform);
-
-#endif
 #ifdef VK_AMD_memory_overallocation_behavior
 void transform_tohost_VkDeviceMemoryOverallocationCreateInfoAMD(
     VkDecoderGlobalState* resourceTracker, VkDeviceMemoryOverallocationCreateInfoAMD* toTransform);
@@ -4537,17 +5008,17 @@ void transform_fromhost_VkPresentFrameTokenGGP(VkDecoderGlobalState* resourceTra
 
 #endif
 #ifdef VK_EXT_pipeline_creation_feedback
-void transform_tohost_VkPipelineCreationFeedbackEXT(VkDecoderGlobalState* resourceTracker,
-                                                    VkPipelineCreationFeedbackEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineCreationFeedbackCreateInfo,
+                      transform_tohost_VkPipelineCreationFeedbackCreateInfoEXT)
 
-void transform_fromhost_VkPipelineCreationFeedbackEXT(VkDecoderGlobalState* resourceTracker,
-                                                      VkPipelineCreationFeedbackEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineCreationFeedbackCreateInfo,
+                      transform_fromhost_VkPipelineCreationFeedbackCreateInfoEXT)
 
-void transform_tohost_VkPipelineCreationFeedbackCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkPipelineCreationFeedbackCreateInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineCreationFeedback,
+                      transform_tohost_VkPipelineCreationFeedbackEXT)
 
-void transform_fromhost_VkPipelineCreationFeedbackCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkPipelineCreationFeedbackCreateInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineCreationFeedback,
+                      transform_fromhost_VkPipelineCreationFeedbackEXT)
 
 #endif
 #ifdef VK_NV_shader_subgroup_partitioned
@@ -4583,13 +5054,11 @@ void transform_fromhost_VkDrawMeshTasksIndirectCommandNV(
 
 #endif
 #ifdef VK_NV_fragment_shader_barycentric
-void transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
+                      transform_tohost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV)
 
-void transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR,
+                      transform_fromhost_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV)
 
 #endif
 #ifdef VK_NV_shader_image_footprint
@@ -4775,29 +5244,23 @@ DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceScalarBlockLayoutFeatur
 #ifdef VK_GOOGLE_decorate_string
 #endif
 #ifdef VK_EXT_subgroup_size_control
-void transform_tohost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceSubgroupSizeControlFeatures,
+                      transform_tohost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)
 
-void transform_fromhost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceSubgroupSizeControlFeatures,
+                      transform_fromhost_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT)
 
-void transform_tohost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceSubgroupSizeControlProperties,
+                      transform_tohost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT)
 
-void transform_fromhost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceSubgroupSizeControlProperties,
+                      transform_fromhost_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT)
 
-void transform_tohost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      transform_tohost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)
 
-void transform_fromhost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      transform_fromhost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT)
 
 #endif
 #ifdef VK_AMD_shader_core_properties2
@@ -4887,11 +5350,11 @@ void transform_fromhost_VkBufferDeviceAddressCreateInfoEXT(
 
 #endif
 #ifdef VK_EXT_tooling_info
-void transform_tohost_VkPhysicalDeviceToolPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceToolPropertiesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceToolProperties,
+                      transform_tohost_VkPhysicalDeviceToolPropertiesEXT)
 
-void transform_fromhost_VkPhysicalDeviceToolPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceToolPropertiesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceToolProperties,
+                      transform_fromhost_VkPhysicalDeviceToolPropertiesEXT)
 
 #endif
 #ifdef VK_EXT_separate_stencil_usage
@@ -5104,14 +5567,72 @@ void transform_fromhost_VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT(
     VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT* toTransform);
 
 #endif
-#ifdef VK_EXT_shader_demote_to_helper_invocation
-void transform_tohost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+#ifdef VK_EXT_surface_maintenance1
+void transform_tohost_VkSurfacePresentModeEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkSurfacePresentModeEXT* toTransform);
+
+void transform_fromhost_VkSurfacePresentModeEXT(VkDecoderGlobalState* resourceTracker,
+                                                VkSurfacePresentModeEXT* toTransform);
+
+void transform_tohost_VkSurfacePresentScalingCapabilitiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkSurfacePresentScalingCapabilitiesEXT* toTransform);
+
+void transform_fromhost_VkSurfacePresentScalingCapabilitiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkSurfacePresentScalingCapabilitiesEXT* toTransform);
+
+void transform_tohost_VkSurfacePresentModeCompatibilityEXT(
+    VkDecoderGlobalState* resourceTracker, VkSurfacePresentModeCompatibilityEXT* toTransform);
+
+void transform_fromhost_VkSurfacePresentModeCompatibilityEXT(
+    VkDecoderGlobalState* resourceTracker, VkSurfacePresentModeCompatibilityEXT* toTransform);
+
+#endif
+#ifdef VK_EXT_swapchain_maintenance1
+void transform_tohost_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toTransform);
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* toTransform);
 
-void transform_fromhost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(
+void transform_fromhost_VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* toTransform);
+    VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT* toTransform);
+
+void transform_tohost_VkSwapchainPresentFenceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkSwapchainPresentFenceInfoEXT* toTransform);
+
+void transform_fromhost_VkSwapchainPresentFenceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                       VkSwapchainPresentFenceInfoEXT* toTransform);
+
+void transform_tohost_VkSwapchainPresentModesCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainPresentModesCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkSwapchainPresentModesCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainPresentModesCreateInfoEXT* toTransform);
+
+void transform_tohost_VkSwapchainPresentModeInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkSwapchainPresentModeInfoEXT* toTransform);
+
+void transform_fromhost_VkSwapchainPresentModeInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkSwapchainPresentModeInfoEXT* toTransform);
+
+void transform_tohost_VkSwapchainPresentScalingCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainPresentScalingCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkSwapchainPresentScalingCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainPresentScalingCreateInfoEXT* toTransform);
+
+void transform_tohost_VkReleaseSwapchainImagesInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkReleaseSwapchainImagesInfoEXT* toTransform);
+
+void transform_fromhost_VkReleaseSwapchainImagesInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkReleaseSwapchainImagesInfoEXT* toTransform);
+
+#endif
+#ifdef VK_EXT_shader_demote_to_helper_invocation
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures,
+                      transform_tohost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)
+
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures,
+                      transform_fromhost_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT)
 
 #endif
 #ifdef VK_NV_device_generated_commands
@@ -5227,13 +5748,11 @@ void transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
     VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* toTransform);
 
-void transform_tohost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceTexelBufferAlignmentProperties,
+                      transform_tohost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)
 
-void transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentProperties,
+                      transform_fromhost_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT)
 
 #endif
 #ifdef VK_QCOM_render_pass_transform
@@ -5316,34 +5835,52 @@ void transform_fromhost_VkPhysicalDeviceCustomBorderColorFeaturesEXT(
 #endif
 #ifdef VK_GOOGLE_user_type
 #endif
+#ifdef VK_NV_present_barrier
+void transform_tohost_VkPhysicalDevicePresentBarrierFeaturesNV(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDevicePresentBarrierFeaturesNV* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePresentBarrierFeaturesNV(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDevicePresentBarrierFeaturesNV* toTransform);
+
+void transform_tohost_VkSurfaceCapabilitiesPresentBarrierNV(
+    VkDecoderGlobalState* resourceTracker, VkSurfaceCapabilitiesPresentBarrierNV* toTransform);
+
+void transform_fromhost_VkSurfaceCapabilitiesPresentBarrierNV(
+    VkDecoderGlobalState* resourceTracker, VkSurfaceCapabilitiesPresentBarrierNV* toTransform);
+
+void transform_tohost_VkSwapchainPresentBarrierCreateInfoNV(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainPresentBarrierCreateInfoNV* toTransform);
+
+void transform_fromhost_VkSwapchainPresentBarrierCreateInfoNV(
+    VkDecoderGlobalState* resourceTracker, VkSwapchainPresentBarrierCreateInfoNV* toTransform);
+
+#endif
 #ifdef VK_EXT_private_data
-void transform_tohost_VkPhysicalDevicePrivateDataFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDevicePrivateDataFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDevicePrivateDataFeatures,
+                      transform_tohost_VkPhysicalDevicePrivateDataFeaturesEXT)
 
-void transform_fromhost_VkPhysicalDevicePrivateDataFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDevicePrivateDataFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDevicePrivateDataFeatures,
+                      transform_fromhost_VkPhysicalDevicePrivateDataFeaturesEXT)
 
-void transform_tohost_VkDevicePrivateDataCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkDevicePrivateDataCreateInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkDevicePrivateDataCreateInfo,
+                      transform_tohost_VkDevicePrivateDataCreateInfoEXT)
 
-void transform_fromhost_VkDevicePrivateDataCreateInfoEXT(
-    VkDecoderGlobalState* resourceTracker, VkDevicePrivateDataCreateInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkDevicePrivateDataCreateInfo,
+                      transform_fromhost_VkDevicePrivateDataCreateInfoEXT)
 
-void transform_tohost_VkPrivateDataSlotCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
-                                                     VkPrivateDataSlotCreateInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPrivateDataSlotCreateInfo,
+                      transform_tohost_VkPrivateDataSlotCreateInfoEXT)
 
-void transform_fromhost_VkPrivateDataSlotCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
-                                                       VkPrivateDataSlotCreateInfoEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPrivateDataSlotCreateInfo,
+                      transform_fromhost_VkPrivateDataSlotCreateInfoEXT)
 
 #endif
 #ifdef VK_EXT_pipeline_creation_cache_control
-void transform_tohost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDevicePipelineCreationCacheControlFeatures,
+                      transform_tohost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT)
 
-void transform_fromhost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDevicePipelineCreationCacheControlFeatures,
+                      transform_fromhost_VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT)
 
 #endif
 #ifdef VK_NV_device_diagnostics_config
@@ -5364,6 +5901,218 @@ void transform_fromhost_VkDeviceDiagnosticsConfigCreateInfoNV(
 #endif
 #ifdef VK_QCOM_render_pass_store_ops
 #endif
+#ifdef VK_NV_low_latency
+void transform_tohost_VkQueryLowLatencySupportNV(VkDecoderGlobalState* resourceTracker,
+                                                 VkQueryLowLatencySupportNV* toTransform);
+
+void transform_fromhost_VkQueryLowLatencySupportNV(VkDecoderGlobalState* resourceTracker,
+                                                   VkQueryLowLatencySupportNV* toTransform);
+
+#endif
+#ifdef VK_EXT_metal_objects
+void transform_tohost_VkExportMetalObjectCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkExportMetalObjectCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkExportMetalObjectCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkExportMetalObjectCreateInfoEXT* toTransform);
+
+void transform_tohost_VkExportMetalObjectsInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkExportMetalObjectsInfoEXT* toTransform);
+
+void transform_fromhost_VkExportMetalObjectsInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkExportMetalObjectsInfoEXT* toTransform);
+
+void transform_tohost_VkExportMetalDeviceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkExportMetalDeviceInfoEXT* toTransform);
+
+void transform_fromhost_VkExportMetalDeviceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkExportMetalDeviceInfoEXT* toTransform);
+
+void transform_tohost_VkExportMetalCommandQueueInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkExportMetalCommandQueueInfoEXT* toTransform);
+
+void transform_fromhost_VkExportMetalCommandQueueInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkExportMetalCommandQueueInfoEXT* toTransform);
+
+void transform_tohost_VkExportMetalBufferInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkExportMetalBufferInfoEXT* toTransform);
+
+void transform_fromhost_VkExportMetalBufferInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkExportMetalBufferInfoEXT* toTransform);
+
+void transform_tohost_VkImportMetalBufferInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkImportMetalBufferInfoEXT* toTransform);
+
+void transform_fromhost_VkImportMetalBufferInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkImportMetalBufferInfoEXT* toTransform);
+
+void transform_tohost_VkExportMetalTextureInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkExportMetalTextureInfoEXT* toTransform);
+
+void transform_fromhost_VkExportMetalTextureInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkExportMetalTextureInfoEXT* toTransform);
+
+void transform_tohost_VkImportMetalTextureInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkImportMetalTextureInfoEXT* toTransform);
+
+void transform_fromhost_VkImportMetalTextureInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkImportMetalTextureInfoEXT* toTransform);
+
+void transform_tohost_VkExportMetalIOSurfaceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkExportMetalIOSurfaceInfoEXT* toTransform);
+
+void transform_fromhost_VkExportMetalIOSurfaceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkExportMetalIOSurfaceInfoEXT* toTransform);
+
+void transform_tohost_VkImportMetalIOSurfaceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkImportMetalIOSurfaceInfoEXT* toTransform);
+
+void transform_fromhost_VkImportMetalIOSurfaceInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkImportMetalIOSurfaceInfoEXT* toTransform);
+
+void transform_tohost_VkExportMetalSharedEventInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkExportMetalSharedEventInfoEXT* toTransform);
+
+void transform_fromhost_VkExportMetalSharedEventInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkExportMetalSharedEventInfoEXT* toTransform);
+
+void transform_tohost_VkImportMetalSharedEventInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkImportMetalSharedEventInfoEXT* toTransform);
+
+void transform_fromhost_VkImportMetalSharedEventInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkImportMetalSharedEventInfoEXT* toTransform);
+
+#endif
+#ifdef VK_EXT_descriptor_buffer
+void transform_tohost_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceDescriptorBufferPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorBufferPropertiesEXT* toTransform);
+
+void transform_tohost_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT* toTransform);
+
+void transform_tohost_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceDescriptorBufferFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorBufferFeaturesEXT* toTransform);
+
+void transform_tohost_VkDescriptorAddressInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkDescriptorAddressInfoEXT* toTransform);
+
+void transform_fromhost_VkDescriptorAddressInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkDescriptorAddressInfoEXT* toTransform);
+
+void transform_tohost_VkDescriptorBufferBindingInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkDescriptorBufferBindingInfoEXT* toTransform);
+
+void transform_fromhost_VkDescriptorBufferBindingInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkDescriptorBufferBindingInfoEXT* toTransform);
+
+void transform_tohost_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* toTransform);
+
+void transform_fromhost_VkDescriptorBufferBindingPushDescriptorBufferHandleEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkDescriptorBufferBindingPushDescriptorBufferHandleEXT* toTransform);
+
+void transform_tohost_VkDescriptorDataEXT(VkDecoderGlobalState* resourceTracker,
+                                          VkDescriptorDataEXT* toTransform);
+
+void transform_fromhost_VkDescriptorDataEXT(VkDecoderGlobalState* resourceTracker,
+                                            VkDescriptorDataEXT* toTransform);
+
+void transform_tohost_VkDescriptorGetInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkDescriptorGetInfoEXT* toTransform);
+
+void transform_fromhost_VkDescriptorGetInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkDescriptorGetInfoEXT* toTransform);
+
+void transform_tohost_VkBufferCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkBufferCaptureDescriptorDataInfoEXT* toTransform);
+
+void transform_fromhost_VkBufferCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkBufferCaptureDescriptorDataInfoEXT* toTransform);
+
+void transform_tohost_VkImageCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkImageCaptureDescriptorDataInfoEXT* toTransform);
+
+void transform_fromhost_VkImageCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkImageCaptureDescriptorDataInfoEXT* toTransform);
+
+void transform_tohost_VkImageViewCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkImageViewCaptureDescriptorDataInfoEXT* toTransform);
+
+void transform_fromhost_VkImageViewCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkImageViewCaptureDescriptorDataInfoEXT* toTransform);
+
+void transform_tohost_VkSamplerCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkSamplerCaptureDescriptorDataInfoEXT* toTransform);
+
+void transform_fromhost_VkSamplerCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkSamplerCaptureDescriptorDataInfoEXT* toTransform);
+
+void transform_tohost_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkOpaqueCaptureDescriptorDataCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkOpaqueCaptureDescriptorDataCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkOpaqueCaptureDescriptorDataCreateInfoEXT* toTransform);
+
+void transform_tohost_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT* toTransform);
+
+void transform_fromhost_VkAccelerationStructureCaptureDescriptorDataInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkAccelerationStructureCaptureDescriptorDataInfoEXT* toTransform);
+
+#endif
+#ifdef VK_EXT_graphics_pipeline_library
+void transform_tohost_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT* toTransform);
+
+void transform_tohost_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT* toTransform);
+
+void transform_tohost_VkGraphicsPipelineLibraryCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkGraphicsPipelineLibraryCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkGraphicsPipelineLibraryCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkGraphicsPipelineLibraryCreateInfoEXT* toTransform);
+
+#endif
+#ifdef VK_AMD_shader_early_and_late_fragment_tests
+void transform_tohost_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD* toTransform);
+
+#endif
 #ifdef VK_NV_fragment_shading_rate_enums
 void transform_tohost_VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV(
     VkDecoderGlobalState* resourceTracker,
@@ -5490,11 +6239,55 @@ void transform_fromhost_VkCopyCommandTransformInfoQCOM(VkDecoderGlobalState* res
 
 #endif
 #ifdef VK_EXT_image_robustness
-void transform_tohost_VkPhysicalDeviceImageRobustnessFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceImageRobustnessFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceImageRobustnessFeatures,
+                      transform_tohost_VkPhysicalDeviceImageRobustnessFeaturesEXT)
 
-void transform_fromhost_VkPhysicalDeviceImageRobustnessFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceImageRobustnessFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceImageRobustnessFeatures,
+                      transform_fromhost_VkPhysicalDeviceImageRobustnessFeaturesEXT)
+
+#endif
+#ifdef VK_EXT_image_compression_control
+void transform_tohost_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceImageCompressionControlFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageCompressionControlFeaturesEXT* toTransform);
+
+void transform_tohost_VkImageCompressionControlEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkImageCompressionControlEXT* toTransform);
+
+void transform_fromhost_VkImageCompressionControlEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkImageCompressionControlEXT* toTransform);
+
+void transform_tohost_VkSubresourceLayout2EXT(VkDecoderGlobalState* resourceTracker,
+                                              VkSubresourceLayout2EXT* toTransform);
+
+void transform_fromhost_VkSubresourceLayout2EXT(VkDecoderGlobalState* resourceTracker,
+                                                VkSubresourceLayout2EXT* toTransform);
+
+void transform_tohost_VkImageSubresource2EXT(VkDecoderGlobalState* resourceTracker,
+                                             VkImageSubresource2EXT* toTransform);
+
+void transform_fromhost_VkImageSubresource2EXT(VkDecoderGlobalState* resourceTracker,
+                                               VkImageSubresource2EXT* toTransform);
+
+void transform_tohost_VkImageCompressionPropertiesEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkImageCompressionPropertiesEXT* toTransform);
+
+void transform_fromhost_VkImageCompressionPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkImageCompressionPropertiesEXT* toTransform);
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_layout
+void transform_tohost_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT* toTransform);
 
 #endif
 #ifdef VK_EXT_4444_formats
@@ -5505,6 +6298,64 @@ void transform_fromhost_VkPhysicalDevice4444FormatsFeaturesEXT(
     VkDecoderGlobalState* resourceTracker, VkPhysicalDevice4444FormatsFeaturesEXT* toTransform);
 
 #endif
+#ifdef VK_EXT_device_fault
+void transform_tohost_VkPhysicalDeviceFaultFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceFaultFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceFaultFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceFaultFeaturesEXT* toTransform);
+
+void transform_tohost_VkDeviceFaultCountsEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkDeviceFaultCountsEXT* toTransform);
+
+void transform_fromhost_VkDeviceFaultCountsEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkDeviceFaultCountsEXT* toTransform);
+
+void transform_tohost_VkDeviceFaultAddressInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkDeviceFaultAddressInfoEXT* toTransform);
+
+void transform_fromhost_VkDeviceFaultAddressInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkDeviceFaultAddressInfoEXT* toTransform);
+
+void transform_tohost_VkDeviceFaultVendorInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkDeviceFaultVendorInfoEXT* toTransform);
+
+void transform_fromhost_VkDeviceFaultVendorInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                   VkDeviceFaultVendorInfoEXT* toTransform);
+
+void transform_tohost_VkDeviceFaultInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                           VkDeviceFaultInfoEXT* toTransform);
+
+void transform_fromhost_VkDeviceFaultInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkDeviceFaultInfoEXT* toTransform);
+
+void transform_tohost_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkDeviceFaultVendorBinaryHeaderVersionOneEXT* toTransform);
+
+void transform_fromhost_VkDeviceFaultVendorBinaryHeaderVersionOneEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkDeviceFaultVendorBinaryHeaderVersionOneEXT* toTransform);
+
+#endif
+#ifdef VK_ARM_rasterization_order_attachment_access
+void transform_tohost_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT* toTransform);
+
+DEFINE_ALIAS_FUNCTION(
+    transform_tohost_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
+    transform_tohost_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM)
+
+DEFINE_ALIAS_FUNCTION(
+    transform_fromhost_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT,
+    transform_fromhost_VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM)
+
+#endif
 #ifdef VK_EXT_rgba10x6_formats
 void transform_tohost_VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT(
     VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT* toTransform);
@@ -5524,25 +6375,43 @@ void transform_fromhost_VkDirectFBSurfaceCreateInfoEXT(VkDecoderGlobalState* res
 
 #endif
 #ifdef VK_VALVE_mutable_descriptor_type
-void transform_tohost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+void transform_tohost_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toTransform);
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* toTransform);
 
-void transform_fromhost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE(
+void transform_fromhost_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE* toTransform);
+    VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT* toTransform);
+
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT,
+                      transform_tohost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)
 
-void transform_tohost_VkMutableDescriptorTypeListVALVE(
-    VkDecoderGlobalState* resourceTracker, VkMutableDescriptorTypeListVALVE* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT,
+                      transform_fromhost_VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)
 
-void transform_fromhost_VkMutableDescriptorTypeListVALVE(
-    VkDecoderGlobalState* resourceTracker, VkMutableDescriptorTypeListVALVE* toTransform);
+void transform_tohost_VkMutableDescriptorTypeListEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkMutableDescriptorTypeListEXT* toTransform);
 
-void transform_tohost_VkMutableDescriptorTypeCreateInfoVALVE(
-    VkDecoderGlobalState* resourceTracker, VkMutableDescriptorTypeCreateInfoVALVE* toTransform);
+void transform_fromhost_VkMutableDescriptorTypeListEXT(VkDecoderGlobalState* resourceTracker,
+                                                       VkMutableDescriptorTypeListEXT* toTransform);
 
-void transform_fromhost_VkMutableDescriptorTypeCreateInfoVALVE(
-    VkDecoderGlobalState* resourceTracker, VkMutableDescriptorTypeCreateInfoVALVE* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkMutableDescriptorTypeListEXT,
+                      transform_tohost_VkMutableDescriptorTypeListVALVE)
+
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMutableDescriptorTypeListEXT,
+                      transform_fromhost_VkMutableDescriptorTypeListVALVE)
+
+void transform_tohost_VkMutableDescriptorTypeCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkMutableDescriptorTypeCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkMutableDescriptorTypeCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkMutableDescriptorTypeCreateInfoEXT* toTransform);
+
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkMutableDescriptorTypeCreateInfoEXT,
+                      transform_tohost_VkMutableDescriptorTypeCreateInfoVALVE)
+
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkMutableDescriptorTypeCreateInfoEXT,
+                      transform_fromhost_VkMutableDescriptorTypeCreateInfoVALVE)
 
 #endif
 #ifdef VK_EXT_vertex_input_dynamic_state
@@ -5575,6 +6444,40 @@ void transform_fromhost_VkPhysicalDeviceDrmPropertiesEXT(
     VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceDrmPropertiesEXT* toTransform);
 
 #endif
+#ifdef VK_EXT_device_address_binding_report
+void transform_tohost_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceAddressBindingReportFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceAddressBindingReportFeaturesEXT* toTransform);
+
+void transform_tohost_VkDeviceAddressBindingCallbackDataEXT(
+    VkDecoderGlobalState* resourceTracker, VkDeviceAddressBindingCallbackDataEXT* toTransform);
+
+void transform_fromhost_VkDeviceAddressBindingCallbackDataEXT(
+    VkDecoderGlobalState* resourceTracker, VkDeviceAddressBindingCallbackDataEXT* toTransform);
+
+#endif
+#ifdef VK_EXT_depth_clip_control
+void transform_tohost_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDepthClipControlFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceDepthClipControlFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDepthClipControlFeaturesEXT* toTransform);
+
+void transform_tohost_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPipelineViewportDepthClipControlCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkPipelineViewportDepthClipControlCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPipelineViewportDepthClipControlCreateInfoEXT* toTransform);
+
+#endif
 #ifdef VK_EXT_primitive_topology_list_restart
 void transform_tohost_VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
@@ -5731,6 +6634,48 @@ void transform_fromhost_VkPhysicalDeviceExternalMemoryRDMAFeaturesNV(
     VkPhysicalDeviceExternalMemoryRDMAFeaturesNV* toTransform);
 
 #endif
+#ifdef VK_EXT_pipeline_properties
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineInfoKHR, transform_tohost_VkPipelineInfoEXT)
+
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineInfoKHR, transform_fromhost_VkPipelineInfoEXT)
+
+void transform_tohost_VkPipelinePropertiesIdentifierEXT(
+    VkDecoderGlobalState* resourceTracker, VkPipelinePropertiesIdentifierEXT* toTransform);
+
+void transform_fromhost_VkPipelinePropertiesIdentifierEXT(
+    VkDecoderGlobalState* resourceTracker, VkPipelinePropertiesIdentifierEXT* toTransform);
+
+void transform_tohost_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePipelinePropertiesFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelinePropertiesFeaturesEXT* toTransform);
+
+#endif
+#ifdef VK_EXT_multisampled_render_to_single_sampled
+void transform_tohost_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT* toTransform);
+
+void transform_tohost_VkSubpassResolvePerformanceQueryEXT(
+    VkDecoderGlobalState* resourceTracker, VkSubpassResolvePerformanceQueryEXT* toTransform);
+
+void transform_fromhost_VkSubpassResolvePerformanceQueryEXT(
+    VkDecoderGlobalState* resourceTracker, VkSubpassResolvePerformanceQueryEXT* toTransform);
+
+void transform_tohost_VkMultisampledRenderToSingleSampledInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkMultisampledRenderToSingleSampledInfoEXT* toTransform);
+
+void transform_fromhost_VkMultisampledRenderToSingleSampledInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkMultisampledRenderToSingleSampledInfoEXT* toTransform);
+
+#endif
 #ifdef VK_EXT_extended_dynamic_state2
 void transform_tohost_VkPhysicalDeviceExtendedDynamicState2FeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
@@ -5765,6 +6710,16 @@ void transform_fromhost_VkPipelineColorWriteCreateInfoEXT(
     VkDecoderGlobalState* resourceTracker, VkPipelineColorWriteCreateInfoEXT* toTransform);
 
 #endif
+#ifdef VK_EXT_primitives_generated_query
+void transform_tohost_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT* toTransform);
+
+#endif
 #ifdef VK_GOOGLE_gfxstream
 void transform_tohost_VkImportColorBufferGOOGLE(VkDecoderGlobalState* resourceTracker,
                                                 VkImportColorBufferGOOGLE* toTransform);
@@ -5786,19 +6741,31 @@ void transform_fromhost_VkCreateBlobGOOGLE(VkDecoderGlobalState* resourceTracker
 
 #endif
 #ifdef VK_EXT_global_priority_query
-void transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR,
+                      transform_tohost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT)
 
-void transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT(
-    VkDecoderGlobalState* resourceTracker,
-    VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR,
+                      transform_fromhost_VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT)
 
-void transform_tohost_VkQueueFamilyGlobalPriorityPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkQueueFamilyGlobalPriorityPropertiesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkQueueFamilyGlobalPriorityPropertiesKHR,
+                      transform_tohost_VkQueueFamilyGlobalPriorityPropertiesEXT)
 
-void transform_fromhost_VkQueueFamilyGlobalPriorityPropertiesEXT(
-    VkDecoderGlobalState* resourceTracker, VkQueueFamilyGlobalPriorityPropertiesEXT* toTransform);
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkQueueFamilyGlobalPriorityPropertiesKHR,
+                      transform_fromhost_VkQueueFamilyGlobalPriorityPropertiesEXT)
+
+#endif
+#ifdef VK_EXT_image_view_min_lod
+void transform_tohost_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceImageViewMinLodFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceImageViewMinLodFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceImageViewMinLodFeaturesEXT* toTransform);
+
+void transform_tohost_VkImageViewMinLodCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkImageViewMinLodCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkImageViewMinLodCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                       VkImageViewMinLodCreateInfoEXT* toTransform);
 
 #endif
 #ifdef VK_EXT_multi_draw
@@ -5827,8 +6794,160 @@ void transform_fromhost_VkMultiDrawIndexedInfoEXT(VkDecoderGlobalState* resource
                                                   VkMultiDrawIndexedInfoEXT* toTransform);
 
 #endif
+#ifdef VK_EXT_image_2d_view_of_3d
+void transform_tohost_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceImage2DViewOf3DFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceImage2DViewOf3DFeaturesEXT* toTransform);
+
+#endif
+#ifdef VK_EXT_shader_tile_image
+void transform_tohost_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderTileImageFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderTileImageFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderTileImageFeaturesEXT* toTransform);
+
+void transform_tohost_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderTileImagePropertiesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderTileImagePropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderTileImagePropertiesEXT* toTransform);
+
+#endif
+#ifdef VK_EXT_opacity_micromap
+void transform_tohost_VkMicromapUsageEXT(VkDecoderGlobalState* resourceTracker,
+                                         VkMicromapUsageEXT* toTransform);
+
+void transform_fromhost_VkMicromapUsageEXT(VkDecoderGlobalState* resourceTracker,
+                                           VkMicromapUsageEXT* toTransform);
+
+void transform_tohost_VkDeviceOrHostAddressKHR(VkDecoderGlobalState* resourceTracker,
+                                               VkDeviceOrHostAddressKHR* toTransform);
+
+void transform_fromhost_VkDeviceOrHostAddressKHR(VkDecoderGlobalState* resourceTracker,
+                                                 VkDeviceOrHostAddressKHR* toTransform);
+
+void transform_tohost_VkMicromapBuildInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                             VkMicromapBuildInfoEXT* toTransform);
+
+void transform_fromhost_VkMicromapBuildInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkMicromapBuildInfoEXT* toTransform);
+
+void transform_tohost_VkMicromapCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkMicromapCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkMicromapCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                VkMicromapCreateInfoEXT* toTransform);
+
+void transform_tohost_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceOpacityMicromapFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceOpacityMicromapFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceOpacityMicromapFeaturesEXT* toTransform);
+
+void transform_tohost_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceOpacityMicromapPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceOpacityMicromapPropertiesEXT* toTransform);
+
+void transform_tohost_VkMicromapVersionInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                               VkMicromapVersionInfoEXT* toTransform);
+
+void transform_fromhost_VkMicromapVersionInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                 VkMicromapVersionInfoEXT* toTransform);
+
+void transform_tohost_VkCopyMicromapToMemoryInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkCopyMicromapToMemoryInfoEXT* toTransform);
+
+void transform_fromhost_VkCopyMicromapToMemoryInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkCopyMicromapToMemoryInfoEXT* toTransform);
+
+void transform_tohost_VkCopyMemoryToMicromapInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkCopyMemoryToMicromapInfoEXT* toTransform);
+
+void transform_fromhost_VkCopyMemoryToMicromapInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                      VkCopyMemoryToMicromapInfoEXT* toTransform);
+
+void transform_tohost_VkCopyMicromapInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                            VkCopyMicromapInfoEXT* toTransform);
+
+void transform_fromhost_VkCopyMicromapInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkCopyMicromapInfoEXT* toTransform);
+
+void transform_tohost_VkMicromapBuildSizesInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkMicromapBuildSizesInfoEXT* toTransform);
+
+void transform_fromhost_VkMicromapBuildSizesInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkMicromapBuildSizesInfoEXT* toTransform);
+
+void transform_tohost_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkAccelerationStructureTrianglesOpacityMicromapEXT* toTransform);
+
+void transform_fromhost_VkAccelerationStructureTrianglesOpacityMicromapEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkAccelerationStructureTrianglesOpacityMicromapEXT* toTransform);
+
+void transform_tohost_VkMicromapTriangleEXT(VkDecoderGlobalState* resourceTracker,
+                                            VkMicromapTriangleEXT* toTransform);
+
+void transform_fromhost_VkMicromapTriangleEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkMicromapTriangleEXT* toTransform);
+
+#endif
+#ifdef VK_NV_displacement_micromap
+void transform_tohost_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceDisplacementMicromapFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDisplacementMicromapFeaturesNV* toTransform);
+
+void transform_tohost_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceDisplacementMicromapPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDisplacementMicromapPropertiesNV* toTransform);
+
+void transform_tohost_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkAccelerationStructureTrianglesDisplacementMicromapNV* toTransform);
+
+void transform_fromhost_VkAccelerationStructureTrianglesDisplacementMicromapNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkAccelerationStructureTrianglesDisplacementMicromapNV* toTransform);
+
+#endif
 #ifdef VK_EXT_load_store_op_none
 #endif
+#ifdef VK_HUAWEI_cluster_culling_shader
+void transform_tohost_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI* toTransform);
+
+void transform_tohost_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI* toTransform);
+
+#endif
 #ifdef VK_EXT_border_color_swizzle
 void transform_tohost_VkPhysicalDeviceBorderColorSwizzleFeaturesEXT(
     VkDecoderGlobalState* resourceTracker,
@@ -5857,13 +6976,521 @@ void transform_fromhost_VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT(
     VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT* toTransform);
 
 #endif
-#ifdef VK_KHR_acceleration_structure
-void transform_tohost_VkDeviceOrHostAddressKHR(VkDecoderGlobalState* resourceTracker,
-                                               VkDeviceOrHostAddressKHR* toTransform);
+#ifdef VK_ARM_shader_core_properties
+void transform_tohost_VkPhysicalDeviceShaderCorePropertiesARM(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderCorePropertiesARM* toTransform);
 
-void transform_fromhost_VkDeviceOrHostAddressKHR(VkDecoderGlobalState* resourceTracker,
-                                                 VkDeviceOrHostAddressKHR* toTransform);
+void transform_fromhost_VkPhysicalDeviceShaderCorePropertiesARM(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderCorePropertiesARM* toTransform);
+
+#endif
+#ifdef VK_EXT_image_sliced_view_of_3d
+void transform_tohost_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT* toTransform);
+
+void transform_tohost_VkImageViewSlicedCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkImageViewSlicedCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkImageViewSlicedCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                                       VkImageViewSlicedCreateInfoEXT* toTransform);
+
+#endif
+#ifdef VK_VALVE_descriptor_set_host_mapping
+void transform_tohost_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE* toTransform);
+
+void transform_tohost_VkDescriptorSetBindingReferenceVALVE(
+    VkDecoderGlobalState* resourceTracker, VkDescriptorSetBindingReferenceVALVE* toTransform);
+
+void transform_fromhost_VkDescriptorSetBindingReferenceVALVE(
+    VkDecoderGlobalState* resourceTracker, VkDescriptorSetBindingReferenceVALVE* toTransform);
+
+void transform_tohost_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    VkDecoderGlobalState* resourceTracker, VkDescriptorSetLayoutHostMappingInfoVALVE* toTransform);
+
+void transform_fromhost_VkDescriptorSetLayoutHostMappingInfoVALVE(
+    VkDecoderGlobalState* resourceTracker, VkDescriptorSetLayoutHostMappingInfoVALVE* toTransform);
+
+#endif
+#ifdef VK_EXT_depth_clamp_zero_one
+void transform_tohost_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceDepthClampZeroOneFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceDepthClampZeroOneFeaturesEXT* toTransform);
 
+#endif
+#ifdef VK_EXT_non_seamless_cube_map
+void transform_tohost_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT* toTransform);
+
+#endif
+#ifdef VK_QCOM_fragment_density_map_offset
+void transform_tohost_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM* toTransform);
+
+void transform_tohost_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM* toTransform);
+
+void transform_tohost_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* toTransform);
+
+void transform_fromhost_VkSubpassFragmentDensityMapOffsetEndInfoQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkSubpassFragmentDensityMapOffsetEndInfoQCOM* toTransform);
+
+#endif
+#ifdef VK_NV_copy_memory_indirect
+void transform_tohost_VkCopyMemoryIndirectCommandNV(VkDecoderGlobalState* resourceTracker,
+                                                    VkCopyMemoryIndirectCommandNV* toTransform);
+
+void transform_fromhost_VkCopyMemoryIndirectCommandNV(VkDecoderGlobalState* resourceTracker,
+                                                      VkCopyMemoryIndirectCommandNV* toTransform);
+
+void transform_tohost_VkCopyMemoryToImageIndirectCommandNV(
+    VkDecoderGlobalState* resourceTracker, VkCopyMemoryToImageIndirectCommandNV* toTransform);
+
+void transform_fromhost_VkCopyMemoryToImageIndirectCommandNV(
+    VkDecoderGlobalState* resourceTracker, VkCopyMemoryToImageIndirectCommandNV* toTransform);
+
+void transform_tohost_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceCopyMemoryIndirectFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceCopyMemoryIndirectFeaturesNV* toTransform);
+
+void transform_tohost_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceCopyMemoryIndirectPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceCopyMemoryIndirectPropertiesNV* toTransform);
+
+#endif
+#ifdef VK_NV_memory_decompression
+void transform_tohost_VkDecompressMemoryRegionNV(VkDecoderGlobalState* resourceTracker,
+                                                 VkDecompressMemoryRegionNV* toTransform);
+
+void transform_fromhost_VkDecompressMemoryRegionNV(VkDecoderGlobalState* resourceTracker,
+                                                   VkDecompressMemoryRegionNV* toTransform);
+
+void transform_tohost_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMemoryDecompressionFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMemoryDecompressionFeaturesNV* toTransform);
+
+void transform_tohost_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMemoryDecompressionPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMemoryDecompressionPropertiesNV* toTransform);
+
+#endif
+#ifdef VK_NV_linear_color_attachment
+void transform_tohost_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceLinearColorAttachmentFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceLinearColorAttachmentFeaturesNV* toTransform);
+
+#endif
+#ifdef VK_GOOGLE_surfaceless_query
+#endif
+#ifdef VK_EXT_image_compression_control_swapchain
+void transform_tohost_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT* toTransform);
+
+#endif
+#ifdef VK_QCOM_image_processing
+void transform_tohost_VkImageViewSampleWeightCreateInfoQCOM(
+    VkDecoderGlobalState* resourceTracker, VkImageViewSampleWeightCreateInfoQCOM* toTransform);
+
+void transform_fromhost_VkImageViewSampleWeightCreateInfoQCOM(
+    VkDecoderGlobalState* resourceTracker, VkImageViewSampleWeightCreateInfoQCOM* toTransform);
+
+void transform_tohost_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageProcessingFeaturesQCOM* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceImageProcessingFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageProcessingFeaturesQCOM* toTransform);
+
+void transform_tohost_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageProcessingPropertiesQCOM* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceImageProcessingPropertiesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceImageProcessingPropertiesQCOM* toTransform);
+
+#endif
+#ifdef VK_EXT_extended_dynamic_state3
+void transform_tohost_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceExtendedDynamicState3FeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT* toTransform);
+
+void transform_tohost_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceExtendedDynamicState3PropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceExtendedDynamicState3PropertiesEXT* toTransform);
+
+void transform_tohost_VkColorBlendEquationEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkColorBlendEquationEXT* toTransform);
+
+void transform_fromhost_VkColorBlendEquationEXT(VkDecoderGlobalState* resourceTracker,
+                                                VkColorBlendEquationEXT* toTransform);
+
+void transform_tohost_VkColorBlendAdvancedEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkColorBlendAdvancedEXT* toTransform);
+
+void transform_fromhost_VkColorBlendAdvancedEXT(VkDecoderGlobalState* resourceTracker,
+                                                VkColorBlendAdvancedEXT* toTransform);
+
+#endif
+#ifdef VK_EXT_subpass_merge_feedback
+void transform_tohost_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT* toTransform);
+
+void transform_tohost_VkRenderPassCreationControlEXT(VkDecoderGlobalState* resourceTracker,
+                                                     VkRenderPassCreationControlEXT* toTransform);
+
+void transform_fromhost_VkRenderPassCreationControlEXT(VkDecoderGlobalState* resourceTracker,
+                                                       VkRenderPassCreationControlEXT* toTransform);
+
+void transform_tohost_VkRenderPassCreationFeedbackInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassCreationFeedbackInfoEXT* toTransform);
+
+void transform_fromhost_VkRenderPassCreationFeedbackInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassCreationFeedbackInfoEXT* toTransform);
+
+void transform_tohost_VkRenderPassCreationFeedbackCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassCreationFeedbackCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkRenderPassCreationFeedbackCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassCreationFeedbackCreateInfoEXT* toTransform);
+
+void transform_tohost_VkRenderPassSubpassFeedbackInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassSubpassFeedbackInfoEXT* toTransform);
+
+void transform_fromhost_VkRenderPassSubpassFeedbackInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassSubpassFeedbackInfoEXT* toTransform);
+
+void transform_tohost_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassSubpassFeedbackCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkRenderPassSubpassFeedbackCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker, VkRenderPassSubpassFeedbackCreateInfoEXT* toTransform);
+
+#endif
+#ifdef VK_LUNARG_direct_driver_loading
+void transform_tohost_VkDirectDriverLoadingInfoLUNARG(VkDecoderGlobalState* resourceTracker,
+                                                      VkDirectDriverLoadingInfoLUNARG* toTransform);
+
+void transform_fromhost_VkDirectDriverLoadingInfoLUNARG(
+    VkDecoderGlobalState* resourceTracker, VkDirectDriverLoadingInfoLUNARG* toTransform);
+
+void transform_tohost_VkDirectDriverLoadingListLUNARG(VkDecoderGlobalState* resourceTracker,
+                                                      VkDirectDriverLoadingListLUNARG* toTransform);
+
+void transform_fromhost_VkDirectDriverLoadingListLUNARG(
+    VkDecoderGlobalState* resourceTracker, VkDirectDriverLoadingListLUNARG* toTransform);
+
+#endif
+#ifdef VK_EXT_shader_module_identifier
+void transform_tohost_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT* toTransform);
+
+void transform_tohost_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT* toTransform);
+
+void transform_tohost_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkPipelineShaderStageModuleIdentifierCreateInfoEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPipelineShaderStageModuleIdentifierCreateInfoEXT* toTransform);
+
+void transform_tohost_VkShaderModuleIdentifierEXT(VkDecoderGlobalState* resourceTracker,
+                                                  VkShaderModuleIdentifierEXT* toTransform);
+
+void transform_fromhost_VkShaderModuleIdentifierEXT(VkDecoderGlobalState* resourceTracker,
+                                                    VkShaderModuleIdentifierEXT* toTransform);
+
+#endif
+#ifdef VK_EXT_rasterization_order_attachment_access
+#endif
+#ifdef VK_NV_optical_flow
+void transform_tohost_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceOpticalFlowFeaturesNV* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceOpticalFlowFeaturesNV(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceOpticalFlowFeaturesNV* toTransform);
+
+void transform_tohost_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceOpticalFlowPropertiesNV* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceOpticalFlowPropertiesNV(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceOpticalFlowPropertiesNV* toTransform);
+
+void transform_tohost_VkOpticalFlowImageFormatInfoNV(VkDecoderGlobalState* resourceTracker,
+                                                     VkOpticalFlowImageFormatInfoNV* toTransform);
+
+void transform_fromhost_VkOpticalFlowImageFormatInfoNV(VkDecoderGlobalState* resourceTracker,
+                                                       VkOpticalFlowImageFormatInfoNV* toTransform);
+
+void transform_tohost_VkOpticalFlowImageFormatPropertiesNV(
+    VkDecoderGlobalState* resourceTracker, VkOpticalFlowImageFormatPropertiesNV* toTransform);
+
+void transform_fromhost_VkOpticalFlowImageFormatPropertiesNV(
+    VkDecoderGlobalState* resourceTracker, VkOpticalFlowImageFormatPropertiesNV* toTransform);
+
+void transform_tohost_VkOpticalFlowSessionCreateInfoNV(
+    VkDecoderGlobalState* resourceTracker, VkOpticalFlowSessionCreateInfoNV* toTransform);
+
+void transform_fromhost_VkOpticalFlowSessionCreateInfoNV(
+    VkDecoderGlobalState* resourceTracker, VkOpticalFlowSessionCreateInfoNV* toTransform);
+
+void transform_tohost_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkOpticalFlowSessionCreatePrivateDataInfoNV* toTransform);
+
+void transform_fromhost_VkOpticalFlowSessionCreatePrivateDataInfoNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkOpticalFlowSessionCreatePrivateDataInfoNV* toTransform);
+
+void transform_tohost_VkOpticalFlowExecuteInfoNV(VkDecoderGlobalState* resourceTracker,
+                                                 VkOpticalFlowExecuteInfoNV* toTransform);
+
+void transform_fromhost_VkOpticalFlowExecuteInfoNV(VkDecoderGlobalState* resourceTracker,
+                                                   VkOpticalFlowExecuteInfoNV* toTransform);
+
+#endif
+#ifdef VK_EXT_legacy_dithering
+void transform_tohost_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceLegacyDitheringFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceLegacyDitheringFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceLegacyDitheringFeaturesEXT* toTransform);
+
+#endif
+#ifdef VK_EXT_pipeline_protected_access
+void transform_tohost_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePipelineProtectedAccessFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineProtectedAccessFeaturesEXT* toTransform);
+
+#endif
+#ifdef VK_EXT_shader_object
+void transform_tohost_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderObjectFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderObjectFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderObjectFeaturesEXT* toTransform);
+
+void transform_tohost_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderObjectPropertiesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderObjectPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceShaderObjectPropertiesEXT* toTransform);
+
+void transform_tohost_VkShaderCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                            VkShaderCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkShaderCreateInfoEXT(VkDecoderGlobalState* resourceTracker,
+                                              VkShaderCreateInfoEXT* toTransform);
+
+DEFINE_ALIAS_FUNCTION(transform_tohost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      transform_tohost_VkShaderRequiredSubgroupSizeCreateInfoEXT)
+
+DEFINE_ALIAS_FUNCTION(transform_fromhost_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo,
+                      transform_fromhost_VkShaderRequiredSubgroupSizeCreateInfoEXT)
+
+#endif
+#ifdef VK_QCOM_tile_properties
+void transform_tohost_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceTilePropertiesFeaturesQCOM* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceTilePropertiesFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceTilePropertiesFeaturesQCOM* toTransform);
+
+void transform_tohost_VkTilePropertiesQCOM(VkDecoderGlobalState* resourceTracker,
+                                           VkTilePropertiesQCOM* toTransform);
+
+void transform_fromhost_VkTilePropertiesQCOM(VkDecoderGlobalState* resourceTracker,
+                                             VkTilePropertiesQCOM* toTransform);
+
+#endif
+#ifdef VK_SEC_amigo_profiling
+void transform_tohost_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceAmigoProfilingFeaturesSEC* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceAmigoProfilingFeaturesSEC(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceAmigoProfilingFeaturesSEC* toTransform);
+
+void transform_tohost_VkAmigoProfilingSubmitInfoSEC(VkDecoderGlobalState* resourceTracker,
+                                                    VkAmigoProfilingSubmitInfoSEC* toTransform);
+
+void transform_fromhost_VkAmigoProfilingSubmitInfoSEC(VkDecoderGlobalState* resourceTracker,
+                                                      VkAmigoProfilingSubmitInfoSEC* toTransform);
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_viewports
+void transform_tohost_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM* toTransform);
+
+#endif
+#ifdef VK_NV_ray_tracing_invocation_reorder
+void transform_tohost_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV* toTransform);
+
+void transform_tohost_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV* toTransform);
+
+#endif
+#ifdef VK_EXT_mutable_descriptor_type
+#endif
+#ifdef VK_ARM_shader_core_builtins
+void transform_tohost_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM* toTransform);
+
+void transform_tohost_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM* toTransform);
+
+#endif
+#ifdef VK_EXT_pipeline_library_group_handles
+void transform_tohost_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT* toTransform);
+
+#endif
+#ifdef VK_QCOM_multiview_per_view_render_areas
+void transform_tohost_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM* toTransform);
+
+void transform_tohost_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* toTransform);
+
+void transform_fromhost_VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM(
+    VkDecoderGlobalState* resourceTracker,
+    VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM* toTransform);
+
+#endif
+#ifdef VK_EXT_attachment_feedback_loop_dynamic_state
+void transform_tohost_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker,
+    VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT* toTransform);
+
+#endif
+#ifdef VK_KHR_acceleration_structure
 void transform_tohost_VkAccelerationStructureBuildRangeInfoKHR(
     VkDecoderGlobalState* resourceTracker, VkAccelerationStructureBuildRangeInfoKHR* toTransform);
 
@@ -6039,6 +7666,26 @@ void transform_fromhost_VkPhysicalDeviceRayQueryFeaturesKHR(
     VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceRayQueryFeaturesKHR* toTransform);
 
 #endif
+#ifdef VK_EXT_mesh_shader
+void transform_tohost_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMeshShaderFeaturesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMeshShaderFeaturesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMeshShaderFeaturesEXT* toTransform);
+
+void transform_tohost_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMeshShaderPropertiesEXT* toTransform);
+
+void transform_fromhost_VkPhysicalDeviceMeshShaderPropertiesEXT(
+    VkDecoderGlobalState* resourceTracker, VkPhysicalDeviceMeshShaderPropertiesEXT* toTransform);
+
+void transform_tohost_VkDrawMeshTasksIndirectCommandEXT(
+    VkDecoderGlobalState* resourceTracker, VkDrawMeshTasksIndirectCommandEXT* toTransform);
+
+void transform_fromhost_VkDrawMeshTasksIndirectCommandEXT(
+    VkDecoderGlobalState* resourceTracker, VkDrawMeshTasksIndirectCommandEXT* toTransform);
+
+#endif
 
 }  // namespace vk
 }  // namespace gfxstream
diff --git a/stream-servers/vulkan/cereal/common/vk_struct_id.h b/stream-servers/vulkan/cereal/common/vk_struct_id.h
index 89fb7a66..d904195a 100644
--- a/stream-servers/vulkan/cereal/common/vk_struct_id.h
+++ b/stream-servers/vulkan/cereal/common/vk_struct_id.h
@@ -66,5 +66,6 @@ REGISTER_VK_STRUCT_ID(VkPhysicalDeviceSamplerYcbcrConversionFeatures, VK_STRUCTU
 REGISTER_VK_STRUCT_ID(VkDeviceCreateInfo, VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO)
 REGISTER_VK_STRUCT_ID(VkFenceCreateInfo, VK_STRUCTURE_TYPE_FENCE_CREATE_INFO);
 REGISTER_VK_STRUCT_ID(VkExportFenceCreateInfo, VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO);
+REGISTER_VK_STRUCT_ID(VkBindImageMemoryInfo, VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO);
 
 #undef REGISTER_VK_STRUCT_ID
diff --git a/stream-servers/vulkan/vk_android_native_buffer.h b/stream-servers/vulkan/vk_android_native_buffer.h
index a0f89f8d..4ae8f8bd 100644
--- a/stream-servers/vulkan/vk_android_native_buffer.h
+++ b/stream-servers/vulkan/vk_android_native_buffer.h
@@ -30,10 +30,21 @@ extern "C" {
 #ifndef VK_ANDROID_native_buffer
 
 #define VK_ANDROID_native_buffer 1
-#define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 6
+#define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 8
 #define VK_ANDROID_NATIVE_BUFFER_NUMBER 11
 #define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME "VK_ANDROID_native_buffer"
 #define VK_ANDROID_NATIVE_BUFFER_NAME VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME
+
+typedef enum VkSwapchainImageUsageFlagBitsANDROID {
+    VK_SWAPCHAIN_IMAGE_USAGE_SHARED_BIT_ANDROID = 0x00000001,
+    VK_SWAPCHAIN_IMAGE_USAGE_FLAG_BITS_MAX_ENUM_ANDROID = 0x7FFFFFFF
+} VkSwapchainImageUsageFlagBitsANDROID;
+typedef VkFlags VkSwapchainImageUsageFlagsANDROID;
+typedef struct VkNativeBufferUsage2ANDROID {
+    uint64_t consumer;
+    uint64_t producer;
+} VkNativeBufferUsage2ANDROID;
+
 typedef struct VkNativeBufferANDROID {
     VkStructureType sType;
     const void* pNext;
@@ -41,10 +52,21 @@ typedef struct VkNativeBufferANDROID {
     int stride;
     int format;
     int usage;
-    uint64_t consumer;
-    uint64_t producer;
+    VkNativeBufferUsage2ANDROID usage2;
 } VkNativeBufferANDROID;
 
+typedef struct VkSwapchainImageCreateInfoANDROID {
+    VkStructureType sType;
+    const void* pNext;
+    VkSwapchainImageUsageFlagsANDROID usage;
+} VkSwapchainImageCreateInfoANDROID;
+
+typedef struct VkPhysicalDevicePresentationPropertiesANDROID {
+    VkStructureType sType;
+    const void* pNext;
+    VkBool32 sharedImage;
+} VkPhysicalDevicePresentationPropertiesANDROID;
+
 typedef VkResult(VKAPI_PTR* PFN_vkGetSwapchainGrallocUsageANDROID)(VkDevice device, VkFormat format,
                                                                    VkImageUsageFlags imageUsage,
                                                                    int* grallocUsage);
@@ -54,6 +76,10 @@ typedef VkResult(VKAPI_PTR* PFN_vkAcquireImageANDROID)(VkDevice device, VkImage
 typedef VkResult(VKAPI_PTR* PFN_vkQueueSignalReleaseImageANDROID)(
     VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image,
     int* pNativeFenceFd);
+typedef VkResult(VKAPI_PTR* PFN_vkGetSwapchainGrallocUsage2ANDROID)(
+    VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
+    VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage,
+    uint64_t* grallocProducerUsage);
 
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format,
@@ -68,6 +94,11 @@ VKAPI_ATTR VkResult VKAPI_CALL vkQueueSignalReleaseImageANDROID(VkQueue queue,
                                                                 uint32_t waitSemaphoreCount,
                                                                 const VkSemaphore* pWaitSemaphores,
                                                                 VkImage image, int* pNativeFenceFd);
+
+VKAPI_ATTR VkResult VKAPI_CALL
+vkGetSwapchainGrallocUsage2ANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
+                                   VkSwapchainImageUsageFlagsANDROID swapchainImageUsage,
+                                   uint64_t* grallocConsumerUsage, uint64_t* grallocProducerUsage);
 #endif
 #endif /* VK_ANDROID_native_buffer */
 
diff --git a/stream-servers/vulkan/vk_android_native_buffer_structure_type.h b/stream-servers/vulkan/vk_android_native_buffer_structure_type.h
index 983f85bc..1da0d63b 100644
--- a/stream-servers/vulkan/vk_android_native_buffer_structure_type.h
+++ b/stream-servers/vulkan/vk_android_native_buffer_structure_type.h
@@ -15,8 +15,8 @@
 
 // Autogenerated module vk_android_native_buffer_structure_type
 //
-// (header) generated by registry/vulkan/scripts/genvk.py -registry registry/vulkan/xml/vk.xml
-// cereal -o ../../device/generic/vulkan-cereal/stream-servers/vulkan/cereal
+// (header) generated by codegen/vulkan/scripts/genvk.py -registry codegen/vulkan/xml/vk.xml
+// -registryGfxstream codegen/vulkan/xml/vk_gfxstream.xml cereal -o host/vulkan/cereal
 //
 // Please do not modify directly;
 // re-run gfxstream-protocols/scripts/generate-vulkan-sources.sh,
@@ -34,3 +34,7 @@
     ((type)(1000000000 + (1000 * (VK_ANDROID_NATIVE_BUFFER_NUMBER - 1)) + (id)))
 
 #define VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 0)
+#define VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID \
+    VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 1)
+#define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID \
+    VK_ANDROID_NATIVE_BUFFER_ENUM(VkStructureType, 2)
diff --git a/stream-servers/vulkan/vulkan_gfxstream.h b/stream-servers/vulkan/vulkan_gfxstream.h
index 060dac5c..53431f82 100644
--- a/stream-servers/vulkan/vulkan_gfxstream.h
+++ b/stream-servers/vulkan/vulkan_gfxstream.h
@@ -119,6 +119,14 @@ typedef void(VKAPI_PTR* PFN_vkQueueFlushCommandsFromAuxMemoryGOOGLE)(VkQueue que
                                                                      VkDeviceSize dataOffset,
                                                                      VkDeviceSize dataSize);
 typedef VkResult(VKAPI_PTR* PFN_vkGetBlobGOOGLE)(VkDevice device, VkDeviceMemory memory);
+typedef void(VKAPI_PTR* PFN_vkUpdateDescriptorSetWithTemplateSized2GOOGLE)(
+    VkDevice device, VkDescriptorSet descriptorSet,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+    uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
+    const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
+    const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
+    const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
+    const uint8_t* pInlineUniformBlockData);
 
 #ifndef VK_NO_PROTOTYPES
 VKAPI_ATTR VkResult VKAPI_CALL vkMapMemoryIntoAddressSpaceGOOGLE(VkDevice device,
@@ -208,6 +216,15 @@ VKAPI_ATTR void VKAPI_CALL vkQueueFlushCommandsFromAuxMemoryGOOGLE(VkQueue queue
                                                                    VkDeviceSize dataSize);
 
 VKAPI_ATTR VkResult VKAPI_CALL vkGetBlobGOOGLE(VkDevice device, VkDeviceMemory memory);
+
+VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateSized2GOOGLE(
+    VkDevice device, VkDescriptorSet descriptorSet,
+    VkDescriptorUpdateTemplate descriptorUpdateTemplate, uint32_t imageInfoCount,
+    uint32_t bufferInfoCount, uint32_t bufferViewCount, uint32_t inlineUniformBlockCount,
+    const uint32_t* pImageInfoEntryIndices, const uint32_t* pBufferInfoEntryIndices,
+    const uint32_t* pBufferViewEntryIndices, const VkDescriptorImageInfo* pImageInfos,
+    const VkDescriptorBufferInfo* pBufferInfos, const VkBufferView* pBufferViews,
+    const uint8_t* pInlineUniformBlockData);
 #endif
 
 #ifdef __cplusplus