diff --git a/Android.mk b/Android.mk
index 2c0a5c2..7afa40a 100644
--- a/Android.mk
+++ b/Android.mk
@@ -149,6 +149,11 @@
 include $(GOLDFISH_OPENGL_PATH)/system/GLESv2/Android.mk
 
 include $(GOLDFISH_OPENGL_PATH)/system/gralloc/Android.mk
+
+ifneq (true,$(GOLDFISH_OPENGL_BUILD_FOR_HOST))
+include $(GOLDFISH_OPENGL_PATH)/system/hals/Android.mk
+endif
+
 include $(GOLDFISH_OPENGL_PATH)/system/cbmanager/Android.mk
 
 include $(GOLDFISH_OPENGL_PATH)/system/egl/Android.mk
diff --git a/CMakeLists.txt b/CMakeLists.txt
index eba847a..9c58ad1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2,7 +2,7 @@
 # instead run make from .../device/generic/goldfish-opengl
 # which will re-generate this file.
 set(GOLDFISH_DEVICE_ROOT ${CMAKE_CURRENT_SOURCE_DIR})
-android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/./Android.mk" "2c3250b596a2b161e479dd3624a74ae6e485d6238d59d9a5dc55064c46482943")
+android_validate_sha256("${GOLDFISH_DEVICE_ROOT}/./Android.mk" "c8e5536771d09cd120c3e396beac994a1e2d2880f37b4e3bd1844be4cfc31555")
 add_subdirectory(shared/OpenglCodecCommon)
 add_subdirectory(system/GLESv1_enc)
 add_subdirectory(system/GLESv2_enc)
@@ -14,4 +14,4 @@
 add_subdirectory(system/GLESv2)
 add_subdirectory(system/gralloc)
 add_subdirectory(system/egl)
-add_subdirectory(system/vulkan)
+add_subdirectory(system/vulkan)
\ No newline at end of file
diff --git a/system/OpenglSystemCommon/EmulatorFeatureInfo.h b/system/OpenglSystemCommon/EmulatorFeatureInfo.h
index 13bd8ad..e20c129 100644
--- a/system/OpenglSystemCommon/EmulatorFeatureInfo.h
+++ b/system/OpenglSystemCommon/EmulatorFeatureInfo.h
@@ -88,6 +88,9 @@
 // Vulkan create resources with requirements
 static const char kVulkanCreateResourcesWithRequirements[] = "ANDROID_EMU_vulkan_create_resources_with_requirements";
 
+// Vulkan ignored handles
+static const char kVulkanIgnoredHandles[] = "ANDROID_EMU_vulkan_ignored_handles";
+
 // YUV host cache
 static const char kYUVCache[] = "ANDROID_EMU_YUV_Cache";
 
@@ -107,6 +110,7 @@
         hasDeferredVulkanCommands(false),
         hasVulkanNullOptionalStrings(false),
         hasVulkanCreateResourcesWithRequirements(false),
+        hasVulkanIgnoredHandles(false),
         hasYUVCache (false),
         hasAsyncUnmapBuffer (false) { }
 
@@ -119,6 +123,7 @@
     bool hasDeferredVulkanCommands;
     bool hasVulkanNullOptionalStrings;
     bool hasVulkanCreateResourcesWithRequirements;
+    bool hasVulkanIgnoredHandles;
     bool hasYUVCache;
     bool hasAsyncUnmapBuffer;
 };
diff --git a/system/OpenglSystemCommon/HostConnection.cpp b/system/OpenglSystemCommon/HostConnection.cpp
index b72bc8c..f69b1d5 100644
--- a/system/OpenglSystemCommon/HostConnection.cpp
+++ b/system/OpenglSystemCommon/HostConnection.cpp
@@ -610,6 +610,7 @@
         queryAndSetDeferredVulkanCommandsSupport(m_rcEnc);
         queryAndSetVulkanNullOptionalStringsSupport(m_rcEnc);
         queryAndSetVulkanCreateResourcesWithRequirementsSupport(m_rcEnc);
+        queryAndSetVulkanIgnoredHandles(m_rcEnc);
         queryAndSetYUVCache(m_rcEnc);
         queryAndSetAsyncUnmapBuffer(m_rcEnc);
         if (m_processPipe) {
@@ -788,6 +789,13 @@
     }
 }
 
+void HostConnection::queryAndSetVulkanIgnoredHandles(ExtendedRCEncoderContext* rcEnc) {
+    std::string glExtensions = queryGLExtensions(rcEnc);
+    if (glExtensions.find(kVulkanIgnoredHandles) != std::string::npos) {
+        rcEnc->featureInfo()->hasVulkanIgnoredHandles = true;
+    }
+}
+
 void HostConnection::queryAndSetYUVCache(ExtendedRCEncoderContext* rcEnc) {
     std::string glExtensions = queryGLExtensions(rcEnc);
     if (glExtensions.find(kYUVCache) != std::string::npos) {
diff --git a/system/OpenglSystemCommon/HostConnection.h b/system/OpenglSystemCommon/HostConnection.h
index 501c254..0f262a3 100644
--- a/system/OpenglSystemCommon/HostConnection.h
+++ b/system/OpenglSystemCommon/HostConnection.h
@@ -200,6 +200,7 @@
     void queryAndSetDeferredVulkanCommandsSupport(ExtendedRCEncoderContext *rcEnc);
     void queryAndSetVulkanNullOptionalStringsSupport(ExtendedRCEncoderContext *rcEnc);
     void queryAndSetVulkanCreateResourcesWithRequirementsSupport(ExtendedRCEncoderContext *rcEnc);
+    void queryAndSetVulkanIgnoredHandles(ExtendedRCEncoderContext *rcEnc);
     void queryAndSetYUVCache(ExtendedRCEncoderContext *mrcEnc);
     void queryAndSetAsyncUnmapBuffer(ExtendedRCEncoderContext *rcEnc);
 
diff --git a/system/hals/Android.mk b/system/hals/Android.mk
new file mode 100644
index 0000000..912a362
--- /dev/null
+++ b/system/hals/Android.mk
@@ -0,0 +1,74 @@
+#
+# Copyright 2015 The Android Open-Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := android.hardware.graphics.allocator@3.0-service
+LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_VENDOR_MODULE := true
+LOCAL_SRC_FILES := allocator3.cpp
+LOCAL_INIT_RC := android.hardware.graphics.allocator@3.0-service.rc
+
+LOCAL_SHARED_LIBRARIES += \
+    android.hardware.graphics.allocator@3.0 \
+    android.hardware.graphics.mapper@3.0 \
+    libOpenglSystemCommon \
+    libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX) \
+    libbase \
+    libcutils \
+    libhidlbase \
+    liblog \
+    libutils
+
+LOCAL_C_INCLUDES += \
+    device/generic/goldfish-opengl/system/include \
+    device/generic/goldfish-opengl/system/OpenglSystemCommon \
+    device/generic/goldfish-opengl/shared/OpenglCodecCommon \
+    device/generic/goldfish-opengl/host/include/libOpenglRender \
+    device/generic/goldfish-opengl/system/renderControl_enc \
+
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := android.hardware.graphics.mapper@3.0-impl
+LOCAL_MODULE_RELATIVE_PATH := hw
+LOCAL_VENDOR_MODULE := true
+LOCAL_SRC_FILES := mapper3.cpp
+
+#     android.hardware.graphics.allocator@3.0 \
+
+LOCAL_SHARED_LIBRARIES += \
+    android.hardware.graphics.mapper@3.0 \
+    libOpenglSystemCommon \
+    libOpenglCodecCommon$(GOLDFISH_OPENGL_LIB_SUFFIX) \
+    libbase \
+    libcutils \
+    libhidlbase \
+    liblog \
+    libutils \
+    libsync
+
+LOCAL_C_INCLUDES += \
+    device/generic/goldfish-opengl/system/include \
+    device/generic/goldfish-opengl/system/OpenglSystemCommon \
+    device/generic/goldfish-opengl/shared/OpenglCodecCommon \
+    device/generic/goldfish-opengl/host/include/libOpenglRender \
+    device/generic/goldfish-opengl/system/renderControl_enc \
+
+include $(BUILD_SHARED_LIBRARY)
+
diff --git a/system/hals/allocator3.cpp b/system/hals/allocator3.cpp
new file mode 100644
index 0000000..e5e182d
--- /dev/null
+++ b/system/hals/allocator3.cpp
@@ -0,0 +1,425 @@
+/*
+* Copyright (C) 2020 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <android/hardware/graphics/allocator/3.0/IAllocator.h>
+#include <android/hardware/graphics/mapper/3.0/IMapper.h>
+#include <hidl/LegacySupport.h>
+
+#include "glUtils.h"
+#include "cb_handle_30.h"
+#include "host_connection_session.h"
+#include "types.h"
+#include "debug.h"
+
+using ::android::hardware::hidl_handle;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::hidl_bitfield;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+
+using ::android::hardware::graphics::common::V1_2::PixelFormat;
+using ::android::hardware::graphics::common::V1_0::BufferUsage;
+
+namespace AllocatorV3 = ::android::hardware::graphics::allocator::V3_0;
+namespace MapperV3 = ::android::hardware::graphics::mapper::V3_0;
+
+using IAllocator3 = AllocatorV3::IAllocator;
+using IMapper3 = MapperV3::IMapper;
+using Error3 = MapperV3::Error;
+using BufferDescriptorInfo = IMapper3::BufferDescriptorInfo;
+
+class GoldfishAllocator : public IAllocator3 {
+public:
+    GoldfishAllocator() : m_hostConn(HostConnection::createUnique()) {}
+
+    Return<void> dumpDebugInfo(dumpDebugInfo_cb hidl_cb) {
+        hidl_cb("GoldfishAllocator::dumpDebugInfo is not implemented");
+        return {};
+    }
+
+    Return<void> allocate(const hidl_vec<uint32_t>& rawDescriptor,
+                          uint32_t count,
+                          allocate_cb hidl_cb) {
+        uint32_t stride = 0;
+        std::vector<cb_handle_30_t*> cbs;
+        cbs.reserve(count);
+
+        const Error3 e = allocateImpl(rawDescriptor, count, &stride, &cbs);
+        if (e == Error3::NONE) {
+            hidl_vec<hidl_handle> handles(cbs.cbegin(), cbs.cend());
+            hidl_cb(Error3::NONE, stride, handles);
+        } else {
+            hidl_cb(e, 0, {});
+        }
+
+        for (cb_handle_30_t* cb : cbs) {
+            freeCb(std::unique_ptr<cb_handle_30_t>(cb));
+        }
+
+        return {};
+    }
+
+private:
+    // this function should be in sync with GoldfishMapper::isSupportedImpl
+    Error3 allocateImpl(const hidl_vec<uint32_t>& rawDescriptor,
+                        uint32_t count,
+                        uint32_t* pStride,
+                        std::vector<cb_handle_30_t*>* cbs) {
+        BufferDescriptorInfo descriptor;
+        if (!decodeBufferDescriptorInfo(rawDescriptor, &descriptor)) {
+            RETURN_ERROR(Error3::BAD_DESCRIPTOR);
+        }
+
+        if (!descriptor.width) { RETURN_ERROR(Error3::UNSUPPORTED); }
+        if (!descriptor.height) { RETURN_ERROR(Error3::UNSUPPORTED); }
+        if (descriptor.layerCount != 1) { RETURN_ERROR(Error3::UNSUPPORTED); }
+
+        const uint32_t usage = descriptor.usage;
+        const bool usageSwWrite = usage & BufferUsage::CPU_WRITE_MASK;
+        const bool usageSwRead = usage & BufferUsage::CPU_READ_MASK;
+        const bool usageHwCamWrite = usage & BufferUsage::CAMERA_OUTPUT;
+        const bool usageHwCamRead = usage & BufferUsage::CAMERA_INPUT;
+
+        int bpp = 1;
+        int glFormat = 0;
+        int glType = 0;
+        int align = 1;
+        bool yuv_format = false;
+        EmulatorFrameworkFormat emulatorFrameworkFormat =
+            EmulatorFrameworkFormat::GL_COMPATIBLE;
+
+        PixelFormat format;
+        Error3 e = getBufferFormat(descriptor.format, usage, &format);
+        if (e != Error3::NONE) {
+            ALOGE("%s:%d Unsupported format: frameworkFormat=%d, usage=%x",
+                  __func__, __LINE__, descriptor.format, usage);
+            return e;
+        }
+
+        switch (format) {
+        case PixelFormat::RGBA_8888:
+        case PixelFormat::RGBX_8888:
+        case PixelFormat::BGRA_8888:
+            bpp = 4;
+            glFormat = GL_RGBA;
+            glType = GL_UNSIGNED_BYTE;
+            break;
+
+        case PixelFormat::RGB_888:
+            if (usage & (BufferUsage::GPU_TEXTURE |
+                         BufferUsage::GPU_RENDER_TARGET |
+                         BufferUsage::COMPOSER_OVERLAY |
+                         BufferUsage::COMPOSER_CLIENT_TARGET)) {
+                RETURN_ERROR(Error3::UNSUPPORTED);
+            } else {
+                bpp = 3;
+                glFormat = GL_RGB;
+                glType = GL_UNSIGNED_BYTE;
+            }
+            break;
+
+        case PixelFormat::RGB_565:
+            bpp = 2;
+            glFormat = GL_RGB565;
+            glType = GL_UNSIGNED_SHORT_5_6_5;
+            break;
+
+        case PixelFormat::RGBA_FP16:
+            bpp = 8;
+            glFormat = GL_RGBA16F;
+            glType = GL_HALF_FLOAT;
+            break;
+
+        case PixelFormat::RGBA_1010102:
+            bpp = 4;
+            glFormat = GL_RGB10_A2;
+            glType = GL_UNSIGNED_INT_2_10_10_10_REV;
+            break;
+
+        case PixelFormat::RAW16:
+        case PixelFormat::Y16:
+            bpp = 2;
+            align = 16 * bpp;
+            if (!((usageSwRead || usageHwCamRead) && (usageSwWrite || usageHwCamWrite))) {
+                // Raw sensor data or Y16 only goes between camera and CPU
+                RETURN_ERROR(Error3::UNSUPPORTED);
+            }
+            // Not expecting to actually create any GL surfaces for this
+            glFormat = GL_LUMINANCE;
+            glType = GL_UNSIGNED_SHORT;
+            break;
+
+        case PixelFormat::BLOB:
+            if (!usageSwRead) {
+                // Blob data cannot be used by HW other than camera emulator
+                // But there is a CTS test trying to have access to it
+                // BUG: https://buganizer.corp.google.com/issues/37719518
+                RETURN_ERROR(Error3::UNSUPPORTED);
+            }
+            // Not expecting to actually create any GL surfaces for this
+            glFormat = GL_LUMINANCE;
+            glType = GL_UNSIGNED_BYTE;
+            break;
+
+        case PixelFormat::YCRCB_420_SP:
+            yuv_format = true;
+            // Not expecting to actually create any GL surfaces for this
+            break;
+
+        case PixelFormat::YV12:
+            align = 16;
+            yuv_format = true;
+            // We are going to use RGB8888 on the host for Vulkan
+            glFormat = GL_RGBA;
+            glType = GL_UNSIGNED_BYTE;
+            emulatorFrameworkFormat = EmulatorFrameworkFormat::YV12;
+            break;
+
+        case PixelFormat::YCBCR_420_888:
+            yuv_format = true;
+            // We are going to use RGB888 on the host
+            glFormat = GL_RGB;
+            glType = GL_UNSIGNED_BYTE;
+            emulatorFrameworkFormat = EmulatorFrameworkFormat::YUV_420_888;
+            break;
+
+        default:
+            ALOGE("%s:%d Unsupported format: format=%d, frameworkFormat=%d, usage=%x",
+                  __func__, __LINE__, format, descriptor.format, usage);
+            RETURN_ERROR(Error3::UNSUPPORTED);
+        }
+
+        const size_t align1 = align - 1;
+        const uint32_t width = descriptor.width;
+        const uint32_t height = descriptor.height;
+        uint32_t stride;
+        size_t bufferSize;
+
+        if (yuv_format) {
+            const size_t yStride = (width * bpp + align1) & ~align1;
+            const size_t uvStride = (yStride / 2 + align1) & ~align1;
+            const size_t uvHeight = height / 2;
+            bufferSize = yStride * height + 2 * (uvHeight * uvStride);
+            stride = yStride / bpp;
+        } else {
+            const size_t bpr = (width * bpp + align1) & ~align1;
+            bufferSize = bpr * height;
+            stride = bpr / bpp;
+        }
+
+        *pStride = stride;
+
+        return allocateImpl2(usage,
+                             width, height,
+                             format, emulatorFrameworkFormat,
+                             glFormat, glType,
+                             bufferSize,
+                             bpp, stride,
+                             count, cbs);
+    }
+
+    Error3 allocateImpl2(const uint32_t usage,
+                         const uint32_t width, const uint32_t height,
+                         const PixelFormat format,
+                         const EmulatorFrameworkFormat emulatorFrameworkFormat,
+                         const int glFormat, const int glType,
+                         const size_t bufferSize,
+                         const uint32_t bytesPerPixel,
+                         const uint32_t stride,
+                         const uint32_t count,
+                         std::vector<cb_handle_30_t*>* cbs) {
+        for (uint32_t i = 0; i < count; ++i) {
+            cb_handle_30_t* cb;
+            Error3 e = allocateCb(usage,
+                                  width, height,
+                                  format, emulatorFrameworkFormat,
+                                  glFormat, glType,
+                                  bufferSize,
+                                  bytesPerPixel, stride,
+                                  &cb);
+            if (e == Error3::NONE) {
+                cbs->push_back(cb);
+            } else {
+                return e;
+            }
+        }
+
+        RETURN(Error3::NONE);
+    }
+
+    // see GoldfishMapper::encodeBufferDescriptorInfo
+    static bool decodeBufferDescriptorInfo(const hidl_vec<uint32_t>& raw,
+                                           BufferDescriptorInfo* d) {
+        if (raw.size() == 5) {
+            d->width = raw[0];
+            d->height = raw[1];
+            d->layerCount = raw[2];
+            d->format = static_cast<PixelFormat>(raw[3]);
+            d->usage = raw[4];
+
+            RETURN(true);
+        } else {
+            RETURN_ERROR(false);
+        }
+    }
+
+    static Error3 getBufferFormat(const PixelFormat frameworkFormat,
+                                  const uint32_t usage,
+                                  PixelFormat* format) {
+        if (frameworkFormat == PixelFormat::IMPLEMENTATION_DEFINED) {
+            if (usage & BufferUsage::CAMERA_OUTPUT) {
+                if (usage & BufferUsage::GPU_TEXTURE) {
+                    // Camera-to-display is RGBA
+                    *format = PixelFormat::RGBA_8888;
+                    RETURN(Error3::NONE);
+                } else if (usage & BufferUsage::VIDEO_ENCODER) {
+                    // Camera-to-encoder is NV21
+                    *format = PixelFormat::YCRCB_420_SP;
+                    RETURN(Error3::NONE);
+                }
+            }
+            RETURN_ERROR(Error3::UNSUPPORTED);
+        } else  {
+            *format = frameworkFormat;
+            RETURN(Error3::NONE);
+        }
+    }
+
+    static bool needHostCb(const uint32_t usage, const PixelFormat format) {
+        return ((usage & BufferUsage::GPU_DATA_BUFFER)
+                   || (format != PixelFormat::BLOB &&
+                       format != PixelFormat::RAW16 &&
+                       format != PixelFormat::Y16))
+               && (usage & (BufferUsage::GPU_TEXTURE
+                            | BufferUsage::GPU_RENDER_TARGET
+                            | BufferUsage::COMPOSER_OVERLAY
+                            | BufferUsage::VIDEO_ENCODER
+                            | BufferUsage::COMPOSER_CLIENT_TARGET
+                            | BufferUsage::CPU_READ_MASK));
+    }
+
+    Error3 allocateCb(const uint32_t usage,
+                      const uint32_t width, const uint32_t height,
+                      const PixelFormat format,
+                      const EmulatorFrameworkFormat emulatorFrameworkFormat,
+                      const int glFormat, const int glType,
+                      const size_t bufferSize,
+                      const int32_t bytesPerPixel,
+                      const int32_t stride,
+                      cb_handle_30_t** cb) {
+        GoldfishAddressSpaceHostMemoryAllocator host_memory_allocator;
+        if (!host_memory_allocator.is_opened()) {
+            RETURN_ERROR(Error3::NO_RESOURCES);
+        }
+
+        GoldfishAddressSpaceBlock bufferBits;
+        if (host_memory_allocator.hostMalloc(&bufferBits, bufferSize)) {
+            RETURN_ERROR(Error3::NO_RESOURCES);
+        }
+
+        uint32_t hostHandle = 0;
+        QEMU_PIPE_HANDLE hostHandleRefCountFd = QEMU_PIPE_INVALID_HANDLE;
+        if (needHostCb(usage, format)) {
+            hostHandleRefCountFd = qemu_pipe_open("refcount");
+            if (!qemu_pipe_valid(hostHandleRefCountFd)) {
+                RETURN_ERROR(Error3::NO_RESOURCES);
+            }
+
+            const GLenum allocFormat =
+                (PixelFormat::RGBX_8888 == format) ? GL_RGB : glFormat;
+
+            const HostConnectionSession conn = getHostConnectionSession();
+            ExtendedRCEncoderContext *const rcEnc = conn.getRcEncoder();
+            CRASH_IF(!rcEnc, "conn.getRcEncoder() failed");
+
+            hostHandle = rcEnc->rcCreateColorBufferDMA(
+                rcEnc,
+                width, height,
+                allocFormat, static_cast<int>(emulatorFrameworkFormat));
+
+            if (!hostHandle) {
+                qemu_pipe_close(hostHandleRefCountFd);
+                RETURN_ERROR(Error3::NO_RESOURCES);
+            }
+
+            if (qemu_pipe_write(hostHandleRefCountFd,
+                                &hostHandle,
+                                sizeof(hostHandle)) != sizeof(hostHandle)) {
+                rcEnc->rcCloseColorBuffer(rcEnc, hostHandle);
+                qemu_pipe_close(hostHandleRefCountFd);
+                RETURN_ERROR(Error3::NO_RESOURCES);
+            }
+        }
+
+        std::unique_ptr<cb_handle_30_t> handle =
+            std::make_unique<cb_handle_30_t>(
+                host_memory_allocator.release(),
+                hostHandleRefCountFd,
+                hostHandle,
+                usage,
+                width,
+                height,
+                static_cast<int>(format),
+                glFormat,
+                glType,
+                bufferSize,
+                bufferBits.guestPtr(),
+                bufferBits.size(),
+                bufferBits.offset(),
+                bytesPerPixel,
+                stride);
+
+        bufferBits.release();
+        *cb = handle.release();
+        RETURN(Error3::NONE);
+    }
+
+    void freeCb(std::unique_ptr<cb_handle_30_t> cb) {
+        // no need to undo .hostMalloc: the kernel will take care of it once the
+        // last bufferFd (duped) is closed.
+
+        if (qemu_pipe_valid(cb->hostHandleRefCountFd)) {
+            qemu_pipe_close(cb->hostHandleRefCountFd);
+        }
+        GoldfishAddressSpaceBlock::memoryUnmap(cb->getBufferPtr(), cb->mmapedSize);
+        GoldfishAddressSpaceHostMemoryAllocator::closeHandle(cb->bufferFd);
+    }
+
+    HostConnectionSession getHostConnectionSession() const {
+        return HostConnectionSession(m_hostConn);
+    }
+
+    //std::unique_ptr<HostConnection> m_hostConn;  // b/142677230
+    HostConnection* m_hostConn;
+};
+
+int main(int, char**) {
+    using ::android::sp;
+
+    ::android::hardware::configureRpcThreadpool(4, true /* callerWillJoin */);
+
+    sp<IAllocator3> allocator(new GoldfishAllocator());
+    if (allocator->registerAsService() != ::android::NO_ERROR) {
+        ALOGE("failed to register graphics IAllocator@3.0 service");
+        return -EINVAL;
+    }
+
+    ALOGI("graphics IAllocator@3.0 service is initialized");
+    ::android::hardware::joinRpcThreadpool();
+
+    ALOGI("graphics IAllocator@3.0 service is terminating");
+    return 0;
+}
diff --git a/system/hals/android.hardware.graphics.allocator@3.0-service.rc b/system/hals/android.hardware.graphics.allocator@3.0-service.rc
new file mode 100644
index 0000000..8b9e13a
--- /dev/null
+++ b/system/hals/android.hardware.graphics.allocator@3.0-service.rc
@@ -0,0 +1,8 @@
+service vendor.gralloc-3-0 /vendor/bin/hw/android.hardware.graphics.allocator@3.0-service
+    interface android.hardware.graphics.allocator@3.0::IAllocator default
+    class hal animation
+    interface android.hardware.graphics.allocator@3.0::IAllocator default
+    user system
+    group graphics drmrpc
+    capabilities SYS_NICE
+    onrestart restart surfaceflinger
diff --git a/system/hals/cb_handle_30.h b/system/hals/cb_handle_30.h
new file mode 100644
index 0000000..11ce322
--- /dev/null
+++ b/system/hals/cb_handle_30.h
@@ -0,0 +1,81 @@
+/*
+* Copyright 2011 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef SYSTEM_HALS_CB_HANDLE_30_H
+#define SYSTEM_HALS_CB_HANDLE_30_H
+
+#include "gralloc_cb.h"
+#include "goldfish_address_space.h"
+
+const uint32_t CB_HANDLE_MAGIC_30 = CB_HANDLE_MAGIC_BASE | 0x2;
+
+struct cb_handle_30_t : public cb_handle_t {
+    cb_handle_30_t(address_space_handle_t p_bufferFd,
+                   QEMU_PIPE_HANDLE p_hostHandleRefCountFd,
+                   uint32_t p_hostHandle,
+                   int32_t p_usage,
+                   int32_t p_width,
+                   int32_t p_height,
+                   int32_t p_format,
+                   int32_t p_glFormat,
+                   int32_t p_glType,
+                   uint32_t p_bufSize,
+                   void* p_bufPtr,
+                   uint32_t p_mmapedSize,
+                   uint64_t p_mmapedOffset,
+                   uint32_t p_bytesPerPixel,
+                   uint32_t p_stride)
+            : cb_handle_t(p_bufferFd,
+                          p_hostHandleRefCountFd,
+                          CB_HANDLE_MAGIC_30,
+                          p_hostHandle,
+                          p_usage,
+                          p_width,
+                          p_height,
+                          p_format,
+                          p_glFormat,
+                          p_glType,
+                          p_bufSize,
+                          p_bufPtr,
+                          p_mmapedOffset),
+              mmapedSize(p_mmapedSize),
+              bytesPerPixel(p_bytesPerPixel),
+              stride(p_stride) {
+        numInts = CB_HANDLE_NUM_INTS(numFds);
+    }
+
+    bool isValid() const { return (version == sizeof(native_handle_t)) && (magic == CB_HANDLE_MAGIC_30); }
+
+    static cb_handle_30_t* from(void* p) {
+        if (!p) { return nullptr; }
+        cb_handle_30_t* cb = static_cast<cb_handle_30_t*>(p);
+        return cb->isValid() ? cb : nullptr;
+    }
+
+    static const cb_handle_30_t* from(const void* p) {
+        return from(const_cast<void*>(p));
+    }
+
+    static cb_handle_30_t* from_unconst(const void* p) {
+        return from(const_cast<void*>(p));
+    }
+
+    uint32_t mmapedSize;            // real allocation side
+    uint32_t bytesPerPixel;
+    uint32_t stride;
+};
+
+#endif // SYSTEM_HALS_CB_HANDLE_30_H
diff --git a/system/hals/debug.h b/system/hals/debug.h
new file mode 100644
index 0000000..f8e41b4
--- /dev/null
+++ b/system/hals/debug.h
@@ -0,0 +1,44 @@
+/*
+* Copyright (C) 2020 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef GOLDFISH_OPENGL_SYSTEM_HALS_DEBUG_H_INCLUDED
+#define GOLDFISH_OPENGL_SYSTEM_HALS_DEBUG_H_INCLUDED
+
+#include <log/log.h>
+
+#define RETURN(X) return (X)
+
+#define RETURN_ERROR(X) \
+    do { \
+        ALOGE("%s:%d failed with '%s'", __func__, __LINE__, #X); \
+        return (X); \
+    } while (false)
+
+#define CRASH(MSG) \
+    do { \
+        ALOGE("%s:%d crashed with '%s'", __func__, __LINE__, MSG); \
+        ::abort(); \
+    } while (false)
+
+#define CRASH_IF(COND, MSG) \
+    do { \
+        if ((COND)) { \
+            ALOGE("%s:%d crashed on '%s' with '%s'", __func__, __LINE__, #COND, MSG); \
+            ::abort(); \
+        } \
+    } while (false)
+
+#endif  // GOLDFISH_OPENGL_SYSTEM_HALS_DEBUG_H_INCLUDED
diff --git a/system/hals/host_connection_session.h b/system/hals/host_connection_session.h
new file mode 100644
index 0000000..12d3b76
--- /dev/null
+++ b/system/hals/host_connection_session.h
@@ -0,0 +1,56 @@
+/*
+* Copyright (C) 2020 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef GOLDFISH_OPENGL_SYSTEM_HALS_HOST_CONNECTION_SESSION_H_INCLUDED
+#define GOLDFISH_OPENGL_SYSTEM_HALS_HOST_CONNECTION_SESSION_H_INCLUDED
+
+#include "HostConnection.h"
+
+class HostConnectionSession {
+public:
+    explicit HostConnectionSession(HostConnection* hc) : conn(hc) {
+        hc->lock();
+    }
+
+    ~HostConnectionSession() {
+        if (conn) {
+            conn->unlock();
+        }
+     }
+
+    HostConnectionSession(HostConnectionSession&& rhs) : conn(rhs.conn) {
+        rhs.conn = nullptr;
+    }
+
+    HostConnectionSession& operator=(HostConnectionSession&& rhs) {
+        if (this != &rhs) {
+            std::swap(conn, rhs.conn);
+        }
+        return *this;
+    }
+
+    HostConnectionSession(const HostConnectionSession&) = delete;
+    HostConnectionSession& operator=(const HostConnectionSession&) = delete;
+
+    ExtendedRCEncoderContext* getRcEncoder() const {
+        return conn->rcEncoder();
+    }
+
+private:
+    HostConnection* conn;
+};
+
+#endif  // GOLDFISH_OPENGL_SYSTEM_HALS_HOST_CONNECTION_SESSION_H_INCLUDED
diff --git a/system/hals/mapper3.cpp b/system/hals/mapper3.cpp
new file mode 100644
index 0000000..99c6514
--- /dev/null
+++ b/system/hals/mapper3.cpp
@@ -0,0 +1,615 @@
+/*
+* Copyright (C) 2020 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <android/hardware/graphics/mapper/3.0/IMapper.h>
+#include <cutils/native_handle.h>
+#include <sync/sync.h>
+
+#include "cb_handle_30.h"
+#include "host_connection_session.h"
+#include "FormatConversions.h"
+#include "debug.h"
+
+using ::android::hardware::hidl_handle;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+
+using ::android::hardware::graphics::common::V1_2::PixelFormat;
+using ::android::hardware::graphics::common::V1_0::BufferUsage;
+
+namespace MapperV3 = ::android::hardware::graphics::mapper::V3_0;
+
+using IMapper3 = MapperV3::IMapper;
+using Error3 = MapperV3::Error;
+using YCbCrLayout3 = MapperV3::YCbCrLayout;
+
+namespace {
+size_t align(const size_t v, const size_t a) { return (v + a - 1) & ~(a - 1); }
+
+static int waitFenceFd(const int fd, const char* logname) {
+    const int warningTimeout = 5000;
+    if (sync_wait(dup(fd), warningTimeout) < 0) {
+        if (errno == ETIME) {
+            ALOGW("%s: fence %d didn't signal in %d ms", logname, fd, warningTimeout);
+            if (sync_wait(fd, -1) < 0) {
+                RETURN_ERROR(errno);
+            } else {
+                RETURN(0);
+            }
+        } else {
+            RETURN_ERROR(errno);
+        }
+    } else {
+        RETURN(0);
+    }
+}
+
+int waitHidlFence(const hidl_handle& hidlHandle, const char* logname) {
+    const native_handle_t* nativeHandle = hidlHandle.getNativeHandle();
+
+    if (!nativeHandle) {
+        RETURN(0);
+    }
+    if (nativeHandle->numFds > 1) {
+        RETURN_ERROR(-EINVAL);
+    }
+    if (nativeHandle->numInts != 0) {
+        RETURN_ERROR(-EINVAL);
+    }
+
+    return waitFenceFd(nativeHandle->data[0], logname);
+}
+
+class GoldfishMapper : public IMapper3 {
+public:
+    GoldfishMapper() : m_hostConn(HostConnection::createUnique()) {
+        GoldfishAddressSpaceHostMemoryAllocator host_memory_allocator;
+        CRASH_IF(!host_memory_allocator.is_opened(),
+                 "GoldfishAddressSpaceHostMemoryAllocator failed to open");
+
+        GoldfishAddressSpaceBlock bufferBits;
+        CRASH_IF(host_memory_allocator.hostMalloc(&bufferBits, 256),
+                 "hostMalloc failed");
+
+        m_physAddrToOffset = bufferBits.physAddr() - bufferBits.offset();
+    }
+
+    Return<void> importBuffer(const hidl_handle& hh,
+                              importBuffer_cb hidl_cb) {
+        native_handle_t* imported = nullptr;
+        const Error3 e = importBufferImpl(hh.getNativeHandle(), &imported);
+        if (e == Error3::NONE) {
+            hidl_cb(Error3::NONE, imported);
+        } else {
+            hidl_cb(e, nullptr);
+        }
+        return {};
+    }
+
+    Return<Error3> freeBuffer(void* raw) {
+        if (!raw) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        cb_handle_30_t* cb = cb_handle_30_t::from(raw);
+        if (!cb) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+
+        if (cb->hostHandle) {
+            const HostConnectionSession conn = getHostConnectionSession();
+            ExtendedRCEncoderContext *const rcEnc = conn.getRcEncoder();
+            rcEnc->rcCloseColorBuffer(rcEnc, cb->hostHandle);
+        }
+
+        if (cb->mmapedSize > 0) {
+            GoldfishAddressSpaceBlock::memoryUnmap(cb->getBufferPtr(), cb->mmapedSize);
+        }
+
+        native_handle_close(cb);
+        native_handle_delete(cb);
+
+        RETURN(Error3::NONE);
+    }
+
+    Return<void> lock(void* raw,
+                      uint64_t cpuUsage,
+                      const Rect& accessRegion,
+                      const hidl_handle& acquireFence,
+                      lock_cb hidl_cb) {
+        void* ptr = nullptr;
+        int32_t bytesPerPixel = 0;
+        int32_t bytesPerStride = 0;
+
+        const Error3 e = lockImpl(raw, cpuUsage, accessRegion, acquireFence,
+                                  &ptr, &bytesPerPixel, &bytesPerStride);
+        if (e == Error3::NONE) {
+            hidl_cb(Error3::NONE, ptr, bytesPerPixel, bytesPerStride);
+        } else {
+            hidl_cb(e, nullptr, 0, 0);
+        }
+        return {};
+    }
+
+    Return<void> lockYCbCr(void* raw,
+                           uint64_t cpuUsage,
+                           const Rect& accessRegion,
+                           const hidl_handle& acquireFence,
+                           lockYCbCr_cb hidl_cb) {
+        YCbCrLayout3 ycbcr = {};
+        const Error3 e = lockYCbCrImpl(raw, cpuUsage, accessRegion, acquireFence,
+                                       &ycbcr);
+        if (e == Error3::NONE) {
+            hidl_cb(Error3::NONE, ycbcr);
+        } else {
+            hidl_cb(e, {});
+        }
+        return {};
+    }
+
+    Return<void> unlock(void* raw, unlock_cb hidl_cb) {
+        hidl_cb(unlockImpl(raw), {});
+        return {};
+
+    }
+
+    Return<void> createDescriptor(const BufferDescriptorInfo& description,
+                                  createDescriptor_cb hidl_cb) {
+        hidl_vec<uint32_t> raw;
+        encodeBufferDescriptorInfo(description, &raw);
+        hidl_cb(Error3::NONE, raw);
+        return {};
+    }
+
+    Return<void> isSupported(const IMapper::BufferDescriptorInfo& description,
+                             isSupported_cb hidl_cb) {
+        hidl_cb(Error3::NONE, isSupportedImpl(description));
+        return {};
+    }
+
+    Return<Error3> validateBufferSize(void* buffer,
+                                      const BufferDescriptorInfo& descriptor,
+                                      uint32_t stride) {
+        const cb_handle_30_t* cb = cb_handle_30_t::from(buffer);
+        if (cb) {
+            return validateBufferSizeImpl(*cb, descriptor, stride);
+        } else {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+    }
+
+    Return<void> getTransportSize(void* buffer,
+                                  getTransportSize_cb hidl_cb) {
+        const cb_handle_30_t* cb = cb_handle_30_t::from(buffer);
+        if (cb) {
+            hidl_cb(Error3::NONE, cb->numFds, cb->numInts);
+        } else {
+            hidl_cb(Error3::BAD_BUFFER, 0, 0);
+        }
+
+        return {};
+    }
+
+private:  // **** impl ****
+    Error3 importBufferImpl(const native_handle_t* nh, native_handle_t** phandle) {
+        if (!nh) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        native_handle_t* imported = native_handle_clone(nh);
+        if (!imported) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        cb_handle_30_t* cb = cb_handle_30_t::from(imported);
+        if (!cb) {
+            native_handle_close(imported);
+            native_handle_delete(imported);
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+
+        if (cb->mmapedSize > 0) {
+            void* ptr;
+            const int res = GoldfishAddressSpaceBlock::memoryMap(
+                cb->getBufferPtr(),
+                cb->mmapedSize,
+                cb->bufferFd,
+                cb->getMmapedOffset(),
+                &ptr);
+            if (res) {
+                native_handle_close(imported);
+                native_handle_delete(imported);
+                RETURN_ERROR(Error3::NO_RESOURCES);
+            }
+            cb->setBufferPtr(ptr);
+        }
+
+        if (cb->hostHandle) {
+            const HostConnectionSession conn = getHostConnectionSession();
+            ExtendedRCEncoderContext *const rcEnc = conn.getRcEncoder();
+            rcEnc->rcOpenColorBuffer2(rcEnc, cb->hostHandle);
+        }
+
+        *phandle = imported;
+        RETURN(Error3::NONE);
+    }
+
+    Error3 lockImpl(void* raw,
+                    uint64_t cpuUsage,
+                    const Rect& accessRegion,
+                    const hidl_handle& acquireFence,
+                    void** pptr,
+                    int32_t* pBytesPerPixel,
+                    int32_t* pBytesPerStride) {
+        if (!raw) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        cb_handle_30_t* cb = cb_handle_30_t::from(raw);
+        if (!cb) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        if (!cb->bufferSize) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        char* const bufferBits = static_cast<char*>(cb->getBufferPtr());
+        if (!bufferBits) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        if (waitHidlFence(acquireFence, __func__)) {
+            RETURN_ERROR(Error3::BAD_VALUE);
+        }
+
+        if (cb->hostHandle) {
+            const Error3 e = lockHostImpl(*cb, cpuUsage, accessRegion, bufferBits);
+            if (e != Error3::NONE) {
+                return e;
+            }
+        }
+
+        *pptr = bufferBits;
+        *pBytesPerPixel = cb->bytesPerPixel;
+        *pBytesPerStride = cb->bytesPerPixel * cb->stride;
+        RETURN(Error3::NONE);
+    }
+
+    Error3 lockYCbCrImpl(void* raw,
+                         uint64_t cpuUsage,
+                         const Rect& accessRegion,
+                         const hidl_handle& acquireFence,
+                         YCbCrLayout3* pYcbcr) {
+        if (!raw) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        cb_handle_30_t* cb = cb_handle_30_t::from(raw);
+        if (!cb) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        if (!cb->bufferSize) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        char* const bufferBits = static_cast<char*>(cb->getBufferPtr());
+        if (!bufferBits) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        if (waitHidlFence(acquireFence, __func__)) {
+            RETURN_ERROR(Error3::BAD_VALUE);
+        }
+
+        size_t uOffset;
+        size_t vOffset;
+        size_t yStride;
+        size_t cStride;
+        size_t cStep;
+        switch (static_cast<PixelFormat>(cb->format)) {
+        case PixelFormat::YCRCB_420_SP:
+            yStride = cb->width;
+            cStride = yStride;
+            vOffset = yStride * cb->height;
+            uOffset = vOffset + 1;
+            cStep = 2;
+            break;
+
+        case PixelFormat::YV12:
+            // https://developer.android.com/reference/android/graphics/ImageFormat.html#YV12
+            yStride = align(cb->width, 16);
+            cStride = align(yStride / 2, 16);
+            vOffset = yStride * cb->height;
+            uOffset = vOffset + (cStride * cb->height / 2);
+            cStep = 1;
+            break;
+
+        case PixelFormat::YCBCR_420_888:
+            yStride = cb->width;
+            cStride = yStride / 2;
+            uOffset = cb->height * yStride;
+            vOffset = uOffset + cStride * cb->height / 2;
+            cStep = 1;
+            break;
+
+        default:
+            ALOGE("%s:%d unexpected format (%d)", __func__, __LINE__, cb->format);
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+
+        if (cb->hostHandle) {
+            const Error3 e = lockHostImpl(*cb, cpuUsage, accessRegion, bufferBits);
+            if (e != Error3::NONE) {
+                return e;
+            }
+        }
+
+        pYcbcr->y = bufferBits;
+        pYcbcr->cb = bufferBits + uOffset;
+        pYcbcr->cr = bufferBits + vOffset;
+        pYcbcr->yStride = yStride;
+        pYcbcr->cStride = cStride;
+        pYcbcr->chromaStep = cStep;
+
+        RETURN(Error3::NONE);
+    }
+
+    Error3 lockHostImpl(cb_handle_30_t& cb,
+                        const uint32_t usage,
+                        const Rect& accessRegion,
+                        char* const bufferBits) {
+        const bool usageSwRead = usage & BufferUsage::CPU_READ_MASK;
+        const bool usageSwWrite = usage & BufferUsage::CPU_WRITE_MASK;
+        const bool usageHwCamera = usage & (BufferUsage::CAMERA_INPUT | BufferUsage::CAMERA_OUTPUT);
+        const bool usageHwCameraWrite = usage & BufferUsage::CAMERA_OUTPUT;
+
+        const HostConnectionSession conn = getHostConnectionSession();
+        ExtendedRCEncoderContext *const rcEnc = conn.getRcEncoder();
+
+        const int res = rcEnc->rcColorBufferCacheFlush(
+            rcEnc, cb.hostHandle, 0, usageSwRead);
+        if (res < 0) {
+            RETURN_ERROR(Error3::NO_RESOURCES);
+        }
+
+        // camera delivers bits to the buffer directly and does not require
+        // an explicit read.
+        if (usageSwRead && !usageHwCamera) {
+            if (gralloc_is_yuv_format(cb.format)) {
+                if (rcEnc->hasYUVCache()) {
+                    uint32_t bufferSize;
+                    switch (static_cast<PixelFormat>(cb.format)) {
+                    case PixelFormat::YV12:
+                        get_yv12_offsets(cb.width, cb.height,
+                                         nullptr, nullptr, &bufferSize);
+                        break;
+                    case PixelFormat::YCBCR_420_888:
+                        get_yuv420p_offsets(cb.width, cb.height,
+                                            nullptr, nullptr, &bufferSize);
+                        break;
+                    default:
+                        CRASH("Unexpected format, switch is out of sync with gralloc_is_yuv_format");
+                        break;
+                    }
+
+                    rcEnc->rcReadColorBufferYUV(rcEnc, cb.hostHandle,
+                        0, 0, cb.width, cb.height,
+                        bufferBits, bufferSize);
+                } else {
+                    // We are using RGB888
+                    std::vector<char> tmpBuf(cb.width * cb.height * 3);
+                    rcEnc->rcReadColorBuffer(rcEnc, cb.hostHandle,
+                                             0, 0, cb.width, cb.height,
+                                             cb.glFormat, cb.glType,
+                                             tmpBuf.data());
+                    switch (static_cast<PixelFormat>(cb.format)) {
+                    case PixelFormat::YV12:
+                        rgb888_to_yv12(bufferBits, tmpBuf.data(),
+                                       cb.width, cb.height,
+                                       accessRegion.left,
+                                       accessRegion.top,
+                                       accessRegion.left + accessRegion.width - 1,
+                                       accessRegion.top + accessRegion.height - 1);
+                        break;
+                    case PixelFormat::YCBCR_420_888:
+                        rgb888_to_yuv420p(bufferBits, tmpBuf.data(),
+                                          cb.width, cb.height,
+                                          accessRegion.left,
+                                          accessRegion.top,
+                                          accessRegion.left + accessRegion.width - 1,
+                                          accessRegion.top + accessRegion.height - 1);
+                        break;
+                    default:
+                        CRASH("Unexpected format, switch is out of sync with gralloc_is_yuv_format");
+                        break;
+                    }
+                }
+            } else {
+                rcEnc->rcReadColorBuffer(rcEnc,
+                                         cb.hostHandle,
+                                         0, 0, cb.width, cb.height,
+                                         cb.glFormat, cb.glType,
+                                         bufferBits);
+            }
+        }
+
+        if (usageSwWrite || usageHwCameraWrite) {
+            cb.lockedLeft = accessRegion.left;
+            cb.lockedTop = accessRegion.top;
+            cb.lockedWidth = accessRegion.width;
+            cb.lockedHeight = accessRegion.height;
+        } else {
+            cb.lockedLeft = 0;
+            cb.lockedTop = 0;
+            cb.lockedWidth = cb.width;
+            cb.lockedHeight = cb.height;
+        }
+
+        RETURN(Error3::NONE);
+    }
+
+    Error3 unlockImpl(void* raw) {
+        if (!raw) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        cb_handle_30_t* cb = cb_handle_30_t::from(raw);
+        if (!cb) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        if (!cb->bufferSize) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+        char* const bufferBits = static_cast<char*>(cb->getBufferPtr());
+        if (!bufferBits) {
+            RETURN_ERROR(Error3::BAD_BUFFER);
+        }
+
+        if (cb->hostHandle) {
+            unlockHostImpl(*cb, bufferBits);
+        }
+
+        RETURN(Error3::NONE);
+    }
+
+    void unlockHostImpl(cb_handle_30_t& cb, char* const bufferBits) {
+        const int bpp = glUtilsPixelBitSize(cb.glFormat, cb.glType) >> 3;
+        const int left = cb.lockedLeft;
+        const int top = cb.lockedTop;
+        const int width = cb.lockedWidth;
+        const int height = cb.lockedHeight;
+        const uint32_t rgbSize = width * height * bpp;
+        std::vector<char> convertedBuf;
+        const char* bitsToSend;
+        uint32_t sizeToSend;
+
+        if (gralloc_is_yuv_format(cb.format)) {
+            bitsToSend = bufferBits;
+            switch (static_cast<PixelFormat>(cb.format)) {
+            case PixelFormat::YV12:
+                get_yv12_offsets(width, height, nullptr, nullptr, &sizeToSend);
+                break;
+            case PixelFormat::YCBCR_420_888:
+                get_yuv420p_offsets(width, height, nullptr, nullptr, &sizeToSend);
+                break;
+            default:
+                CRASH("Unexpected format, switch is out of sync with gralloc_is_yuv_format");
+                break;
+            }
+        } else {
+            convertedBuf.resize(rgbSize);
+            copy_rgb_buffer_from_unlocked(
+                convertedBuf.data(), bufferBits,
+                cb.width,
+                width, height, top, left, bpp);
+            bitsToSend = convertedBuf.data();
+            sizeToSend = rgbSize;
+        }
+
+        {
+            const HostConnectionSession conn = getHostConnectionSession();
+            ExtendedRCEncoderContext *const rcEnc = conn.getRcEncoder();
+            rcEnc->bindDmaDirectly(bufferBits,
+                                   getMmapedPhysAddr(cb.getMmapedOffset()));
+            rcEnc->rcUpdateColorBufferDMA(rcEnc, cb.hostHandle,
+                    left, top, width, height,
+                    cb.glFormat, cb.glType,
+                    const_cast<char*>(bitsToSend), sizeToSend);
+        }
+
+        cb.lockedLeft = 0;
+        cb.lockedTop = 0;
+        cb.lockedWidth = 0;
+        cb.lockedHeight = 0;
+    }
+
+    bool isSupportedImpl(const IMapper::BufferDescriptorInfo& descriptor) const {
+        if (!descriptor.width) { RETURN(false); }
+        if (!descriptor.height) { RETURN(false); }
+        if (descriptor.layerCount != 1) { RETURN(false); }
+
+        const uint32_t usage = descriptor.usage;
+        const bool usageSwWrite = usage & BufferUsage::CPU_WRITE_MASK;
+        const bool usageSwRead = usage & BufferUsage::CPU_READ_MASK;
+        const bool usageHwCamWrite = usage & BufferUsage::CAMERA_OUTPUT;
+        const bool usageHwCamRead = usage & BufferUsage::CAMERA_INPUT;
+
+        switch (descriptor.format) {
+        case PixelFormat::RGBA_8888:
+        case PixelFormat::RGBX_8888:
+        case PixelFormat::BGRA_8888:
+        case PixelFormat::RGB_565:
+        case PixelFormat::RGBA_FP16:
+        case PixelFormat::RGBA_1010102:
+        case PixelFormat::YCRCB_420_SP:
+        case PixelFormat::YV12:
+        case PixelFormat::YCBCR_420_888:
+            RETURN(true);
+
+        case PixelFormat::IMPLEMENTATION_DEFINED:
+            if (usage & BufferUsage::CAMERA_OUTPUT) {
+                if (usage & BufferUsage::GPU_TEXTURE) {
+                    RETURN(true);
+                } else if (usage & BufferUsage::VIDEO_ENCODER) {
+                    RETURN(true);
+                }
+            }
+            RETURN(false);
+
+        case PixelFormat::RGB_888:
+            RETURN(0 == (usage & (BufferUsage::GPU_TEXTURE |
+                                  BufferUsage::GPU_RENDER_TARGET |
+                                  BufferUsage::COMPOSER_OVERLAY |
+                                  BufferUsage::COMPOSER_CLIENT_TARGET)));
+
+        case PixelFormat::RAW16:
+        case PixelFormat::Y16:
+            RETURN((usageSwRead || usageHwCamRead) &&
+                   (usageSwWrite || usageHwCamWrite));
+
+        case PixelFormat::BLOB:
+            RETURN(usageSwRead);
+
+        default:
+            RETURN(false);
+        }
+    }
+
+    Error3 validateBufferSizeImpl(const cb_handle_t& /*cb*/,
+                                  const BufferDescriptorInfo& /*descriptor*/,
+                                  uint32_t /*stride*/) {
+        RETURN(Error3::NONE);
+    }
+
+    HostConnectionSession getHostConnectionSession() const {
+        return HostConnectionSession(m_hostConn);
+    }
+
+    static void encodeBufferDescriptorInfo(const BufferDescriptorInfo& d,
+                                           hidl_vec<uint32_t>* raw) {
+        raw->resize(5);
+
+        (*raw)[0] = d.width;
+        (*raw)[1] = d.height;
+        (*raw)[2] = d.layerCount;
+        (*raw)[3] = static_cast<uint32_t>(d.format);
+        (*raw)[4] = d.usage & UINT32_MAX;
+    }
+
+    uint64_t getMmapedPhysAddr(uint64_t offset) const {
+        return m_physAddrToOffset + offset;
+    }
+
+    //std::unique_ptr<HostConnection> m_hostConn;  // b/142677230
+    HostConnection* m_hostConn;
+    uint64_t m_physAddrToOffset;
+};
+}  // namespace
+
+extern "C" IMapper3* HIDL_FETCH_IMapper(const char* /*name*/) {
+    return new GoldfishMapper;
+}
diff --git a/system/hals/types.h b/system/hals/types.h
new file mode 100644
index 0000000..c7d2646
--- /dev/null
+++ b/system/hals/types.h
@@ -0,0 +1,43 @@
+/*
+* Copyright (C) 2020 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef GOLDFISH_OPENGL_SYSTEM_HALS_TYPES_H_INCLUDED
+#define GOLDFISH_OPENGL_SYSTEM_HALS_TYPES_H_INCLUDED
+
+/* Tell the emulator which formats need special handling. */
+enum class EmulatorFrameworkFormat {
+    GL_COMPATIBLE = 0,
+    YV12 = 1,
+    YUV_420_888 = 2, // (Y+)(U+)(V+)
+};
+
+#ifndef GL_RGBA16F
+#define GL_RGBA16F                        0x881A
+#endif // GL_RGBA16F
+
+#ifndef GL_HALF_FLOAT
+#define GL_HALF_FLOAT                     0x140B
+#endif // GL_HALF_FLOAT
+
+#ifndef GL_RGB10_A2
+#define GL_RGB10_A2                       0x8059
+#endif // GL_RGB10_A2
+
+#ifndef GL_UNSIGNED_INT_2_10_10_10_REV
+#define GL_UNSIGNED_INT_2_10_10_10_REV    0x8368
+#endif // GL_UNSIGNED_INT_2_10_10_10_REV
+
+#endif  // GOLDFISH_OPENGL_SYSTEM_HALS_TYPES_H_INCLUDED
diff --git a/system/vulkan_enc/ResourceTracker.cpp b/system/vulkan_enc/ResourceTracker.cpp
index 1210bc6..9857952 100644
--- a/system/vulkan_enc/ResourceTracker.cpp
+++ b/system/vulkan_enc/ResourceTracker.cpp
@@ -614,6 +614,9 @@
         if (mFeatureInfo->hasVulkanNullOptionalStrings) {
             mStreamFeatureBits |= VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT;
         }
+        if (mFeatureInfo->hasVulkanIgnoredHandles) {
+            mStreamFeatureBits |= VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT;
+        }
     }
 
     void setThreadingCallbacks(const ResourceTracker::ThreadingCallbacks& callbacks) {
diff --git a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
index 6e3aec5..1ef4d04 100644
--- a/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
+++ b/system/vulkan_enc/goldfish_vk_marshaling_guest.cpp
@@ -2594,6 +2594,20 @@
     VulkanStreamGuest* vkStream,
     const VkGraphicsPipelineCreateInfo* forMarshaling)
 {
+    uint32_t hasRasterization = 1;
+    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+    {
+        hasRasterization = (((0 == forMarshaling->pRasterizationState)) ? (0) : (!((*(forMarshaling->pRasterizationState)).rasterizerDiscardEnable)));
+        uint32_t cgen_var_70 = (uint32_t)hasRasterization;
+        vkStream->putBe32(cgen_var_70);
+    }
+    uint32_t hasTessellation = 1;
+    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+    {
+        hasTessellation = arrayany(forMarshaling->pStages, 0, forMarshaling->stageCount, [](VkPipelineShaderStageCreateInfo s) { return ((s.stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) || (s.stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)); });
+        uint32_t cgen_var_71 = (uint32_t)hasTessellation;
+        vkStream->putBe32(cgen_var_71);
+    }
     vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
     size_t pNext_size = goldfish_vk_extension_struct_size(forMarshaling->pNext);
     vkStream->putBe32(pNext_size);
@@ -2608,61 +2622,103 @@
     {
         marshal_VkPipelineShaderStageCreateInfo(vkStream, (const VkPipelineShaderStageCreateInfo*)(forMarshaling->pStages + i));
     }
-    marshal_VkPipelineVertexInputStateCreateInfo(vkStream, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
-    marshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState));
     // WARNING PTR CHECK
-    uint64_t cgen_var_70 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
-    vkStream->putBe64(cgen_var_70);
+    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+    {
+        uint64_t cgen_var_72 = (uint64_t)(uintptr_t)forMarshaling->pVertexInputState;
+        vkStream->putBe64(cgen_var_72);
+    }
+    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pVertexInputState))
+    {
+        marshal_VkPipelineVertexInputStateCreateInfo(vkStream, (const VkPipelineVertexInputStateCreateInfo*)(forMarshaling->pVertexInputState));
+    }
+    // WARNING PTR CHECK
+    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+    {
+        uint64_t cgen_var_73 = (uint64_t)(uintptr_t)forMarshaling->pInputAssemblyState;
+        vkStream->putBe64(cgen_var_73);
+    }
+    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pInputAssemblyState))
+    {
+        marshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (const VkPipelineInputAssemblyStateCreateInfo*)(forMarshaling->pInputAssemblyState));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_74 = (uint64_t)(uintptr_t)forMarshaling->pTessellationState;
+    vkStream->putBe64(cgen_var_74);
     if (forMarshaling->pTessellationState)
     {
-        marshal_VkPipelineTessellationStateCreateInfo(vkStream, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
+        if (hasTessellation)
+        {
+            marshal_VkPipelineTessellationStateCreateInfo(vkStream, (const VkPipelineTessellationStateCreateInfo*)(forMarshaling->pTessellationState));
+        }
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_71 = (uint64_t)(uintptr_t)forMarshaling->pViewportState;
-    vkStream->putBe64(cgen_var_71);
+    uint64_t cgen_var_75 = (uint64_t)(uintptr_t)forMarshaling->pViewportState;
+    vkStream->putBe64(cgen_var_75);
     if (forMarshaling->pViewportState)
     {
-        marshal_VkPipelineViewportStateCreateInfo(vkStream, (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState));
+        if (hasRasterization)
+        {
+            marshal_VkPipelineViewportStateCreateInfo(vkStream, (const VkPipelineViewportStateCreateInfo*)(forMarshaling->pViewportState));
+        }
     }
-    marshal_VkPipelineRasterizationStateCreateInfo(vkStream, (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState));
     // WARNING PTR CHECK
-    uint64_t cgen_var_72 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
-    vkStream->putBe64(cgen_var_72);
+    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+    {
+        uint64_t cgen_var_76 = (uint64_t)(uintptr_t)forMarshaling->pRasterizationState;
+        vkStream->putBe64(cgen_var_76);
+    }
+    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forMarshaling->pRasterizationState))
+    {
+        marshal_VkPipelineRasterizationStateCreateInfo(vkStream, (const VkPipelineRasterizationStateCreateInfo*)(forMarshaling->pRasterizationState));
+    }
+    // WARNING PTR CHECK
+    uint64_t cgen_var_77 = (uint64_t)(uintptr_t)forMarshaling->pMultisampleState;
+    vkStream->putBe64(cgen_var_77);
     if (forMarshaling->pMultisampleState)
     {
-        marshal_VkPipelineMultisampleStateCreateInfo(vkStream, (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState));
+        if (hasRasterization)
+        {
+            marshal_VkPipelineMultisampleStateCreateInfo(vkStream, (const VkPipelineMultisampleStateCreateInfo*)(forMarshaling->pMultisampleState));
+        }
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_73 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilState;
-    vkStream->putBe64(cgen_var_73);
+    uint64_t cgen_var_78 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilState;
+    vkStream->putBe64(cgen_var_78);
     if (forMarshaling->pDepthStencilState)
     {
-        marshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState));
+        if (hasRasterization)
+        {
+            marshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (const VkPipelineDepthStencilStateCreateInfo*)(forMarshaling->pDepthStencilState));
+        }
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_74 = (uint64_t)(uintptr_t)forMarshaling->pColorBlendState;
-    vkStream->putBe64(cgen_var_74);
+    uint64_t cgen_var_79 = (uint64_t)(uintptr_t)forMarshaling->pColorBlendState;
+    vkStream->putBe64(cgen_var_79);
     if (forMarshaling->pColorBlendState)
     {
-        marshal_VkPipelineColorBlendStateCreateInfo(vkStream, (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState));
+        if (hasRasterization)
+        {
+            marshal_VkPipelineColorBlendStateCreateInfo(vkStream, (const VkPipelineColorBlendStateCreateInfo*)(forMarshaling->pColorBlendState));
+        }
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_75 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
-    vkStream->putBe64(cgen_var_75);
+    uint64_t cgen_var_80 = (uint64_t)(uintptr_t)forMarshaling->pDynamicState;
+    vkStream->putBe64(cgen_var_80);
     if (forMarshaling->pDynamicState)
     {
         marshal_VkPipelineDynamicStateCreateInfo(vkStream, (const VkPipelineDynamicStateCreateInfo*)(forMarshaling->pDynamicState));
     }
-    uint64_t cgen_var_76;
-    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_76, 1);
-    vkStream->write((uint64_t*)&cgen_var_76, 1 * 8);
-    uint64_t cgen_var_77;
-    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_77, 1);
-    vkStream->write((uint64_t*)&cgen_var_77, 1 * 8);
+    uint64_t cgen_var_81;
+    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_81, 1);
+    vkStream->write((uint64_t*)&cgen_var_81, 1 * 8);
+    uint64_t cgen_var_82;
+    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_82, 1);
+    vkStream->write((uint64_t*)&cgen_var_82, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
-    uint64_t cgen_var_78;
-    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_78, 1);
-    vkStream->write((uint64_t*)&cgen_var_78, 1 * 8);
+    uint64_t cgen_var_83;
+    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_83, 1);
+    vkStream->write((uint64_t*)&cgen_var_83, 1 * 8);
     vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
 }
 
@@ -2670,6 +2726,16 @@
     VulkanStreamGuest* vkStream,
     VkGraphicsPipelineCreateInfo* forUnmarshaling)
 {
+    uint32_t hasRasterization = 1;
+    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+    {
+        hasRasterization = (const uint32_t)vkStream->getBe32();
+    }
+    uint32_t hasTessellation = 1;
+    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+    {
+        hasTessellation = (const uint32_t)vkStream->getBe32();
+    }
     vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
     size_t pNext_size;
     pNext_size = vkStream->getBe32();
@@ -2685,8 +2751,26 @@
     {
         unmarshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(forUnmarshaling->pStages + i));
     }
-    unmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
-    unmarshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (VkPipelineInputAssemblyStateCreateInfo*)(forUnmarshaling->pInputAssemblyState));
+    // WARNING PTR CHECK
+    const VkPipelineVertexInputStateCreateInfo* check_pVertexInputState;
+    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+    {
+        check_pVertexInputState = (const VkPipelineVertexInputStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+    }
+    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forUnmarshaling->pVertexInputState))
+    {
+        unmarshal_VkPipelineVertexInputStateCreateInfo(vkStream, (VkPipelineVertexInputStateCreateInfo*)(forUnmarshaling->pVertexInputState));
+    }
+    // WARNING PTR CHECK
+    const VkPipelineInputAssemblyStateCreateInfo* check_pInputAssemblyState;
+    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+    {
+        check_pInputAssemblyState = (const VkPipelineInputAssemblyStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+    }
+    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forUnmarshaling->pInputAssemblyState))
+    {
+        unmarshal_VkPipelineInputAssemblyStateCreateInfo(vkStream, (VkPipelineInputAssemblyStateCreateInfo*)(forUnmarshaling->pInputAssemblyState));
+    }
     // WARNING PTR CHECK
     const VkPipelineTessellationStateCreateInfo* check_pTessellationState;
     check_pTessellationState = (const VkPipelineTessellationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
@@ -2696,7 +2780,14 @@
         {
             fprintf(stderr, "fatal: forUnmarshaling->pTessellationState inconsistent between guest and host\n");
         }
-        unmarshal_VkPipelineTessellationStateCreateInfo(vkStream, (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
+        if (hasTessellation)
+        {
+            unmarshal_VkPipelineTessellationStateCreateInfo(vkStream, (VkPipelineTessellationStateCreateInfo*)(forUnmarshaling->pTessellationState));
+        }
+        else
+        {
+            forUnmarshaling->pTessellationState = 0;
+        }
     }
     // WARNING PTR CHECK
     const VkPipelineViewportStateCreateInfo* check_pViewportState;
@@ -2707,9 +2798,25 @@
         {
             fprintf(stderr, "fatal: forUnmarshaling->pViewportState inconsistent between guest and host\n");
         }
-        unmarshal_VkPipelineViewportStateCreateInfo(vkStream, (VkPipelineViewportStateCreateInfo*)(forUnmarshaling->pViewportState));
+        if (hasRasterization)
+        {
+            unmarshal_VkPipelineViewportStateCreateInfo(vkStream, (VkPipelineViewportStateCreateInfo*)(forUnmarshaling->pViewportState));
+        }
+        else
+        {
+            forUnmarshaling->pViewportState = 0;
+        }
     }
-    unmarshal_VkPipelineRasterizationStateCreateInfo(vkStream, (VkPipelineRasterizationStateCreateInfo*)(forUnmarshaling->pRasterizationState));
+    // WARNING PTR CHECK
+    const VkPipelineRasterizationStateCreateInfo* check_pRasterizationState;
+    if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT)
+    {
+        check_pRasterizationState = (const VkPipelineRasterizationStateCreateInfo*)(uintptr_t)vkStream->getBe64();
+    }
+    if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || forUnmarshaling->pRasterizationState))
+    {
+        unmarshal_VkPipelineRasterizationStateCreateInfo(vkStream, (VkPipelineRasterizationStateCreateInfo*)(forUnmarshaling->pRasterizationState));
+    }
     // WARNING PTR CHECK
     const VkPipelineMultisampleStateCreateInfo* check_pMultisampleState;
     check_pMultisampleState = (const VkPipelineMultisampleStateCreateInfo*)(uintptr_t)vkStream->getBe64();
@@ -2719,7 +2826,14 @@
         {
             fprintf(stderr, "fatal: forUnmarshaling->pMultisampleState inconsistent between guest and host\n");
         }
-        unmarshal_VkPipelineMultisampleStateCreateInfo(vkStream, (VkPipelineMultisampleStateCreateInfo*)(forUnmarshaling->pMultisampleState));
+        if (hasRasterization)
+        {
+            unmarshal_VkPipelineMultisampleStateCreateInfo(vkStream, (VkPipelineMultisampleStateCreateInfo*)(forUnmarshaling->pMultisampleState));
+        }
+        else
+        {
+            forUnmarshaling->pMultisampleState = 0;
+        }
     }
     // WARNING PTR CHECK
     const VkPipelineDepthStencilStateCreateInfo* check_pDepthStencilState;
@@ -2730,7 +2844,14 @@
         {
             fprintf(stderr, "fatal: forUnmarshaling->pDepthStencilState inconsistent between guest and host\n");
         }
-        unmarshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (VkPipelineDepthStencilStateCreateInfo*)(forUnmarshaling->pDepthStencilState));
+        if (hasRasterization)
+        {
+            unmarshal_VkPipelineDepthStencilStateCreateInfo(vkStream, (VkPipelineDepthStencilStateCreateInfo*)(forUnmarshaling->pDepthStencilState));
+        }
+        else
+        {
+            forUnmarshaling->pDepthStencilState = 0;
+        }
     }
     // WARNING PTR CHECK
     const VkPipelineColorBlendStateCreateInfo* check_pColorBlendState;
@@ -2741,7 +2862,14 @@
         {
             fprintf(stderr, "fatal: forUnmarshaling->pColorBlendState inconsistent between guest and host\n");
         }
-        unmarshal_VkPipelineColorBlendStateCreateInfo(vkStream, (VkPipelineColorBlendStateCreateInfo*)(forUnmarshaling->pColorBlendState));
+        if (hasRasterization)
+        {
+            unmarshal_VkPipelineColorBlendStateCreateInfo(vkStream, (VkPipelineColorBlendStateCreateInfo*)(forUnmarshaling->pColorBlendState));
+        }
+        else
+        {
+            forUnmarshaling->pColorBlendState = 0;
+        }
     }
     // WARNING PTR CHECK
     const VkPipelineDynamicStateCreateInfo* check_pDynamicState;
@@ -2754,16 +2882,16 @@
         }
         unmarshal_VkPipelineDynamicStateCreateInfo(vkStream, (VkPipelineDynamicStateCreateInfo*)(forUnmarshaling->pDynamicState));
     }
-    uint64_t cgen_var_85;
-    vkStream->read((uint64_t*)&cgen_var_85, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_85, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
-    uint64_t cgen_var_86;
-    vkStream->read((uint64_t*)&cgen_var_86, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_86, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+    uint64_t cgen_var_95;
+    vkStream->read((uint64_t*)&cgen_var_95, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_95, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+    uint64_t cgen_var_96;
+    vkStream->read((uint64_t*)&cgen_var_96, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_96, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
-    uint64_t cgen_var_87;
-    vkStream->read((uint64_t*)&cgen_var_87, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_87, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
+    uint64_t cgen_var_97;
+    vkStream->read((uint64_t*)&cgen_var_97, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_97, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
     vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
 }
 
@@ -2781,12 +2909,12 @@
     }
     vkStream->write((VkPipelineCreateFlags*)&forMarshaling->flags, sizeof(VkPipelineCreateFlags));
     marshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(&forMarshaling->stage));
-    uint64_t cgen_var_88;
-    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_88, 1);
-    vkStream->write((uint64_t*)&cgen_var_88, 1 * 8);
-    uint64_t cgen_var_89;
-    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_89, 1);
-    vkStream->write((uint64_t*)&cgen_var_89, 1 * 8);
+    uint64_t cgen_var_98;
+    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->layout, &cgen_var_98, 1);
+    vkStream->write((uint64_t*)&cgen_var_98, 1 * 8);
+    uint64_t cgen_var_99;
+    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->basePipelineHandle, &cgen_var_99, 1);
+    vkStream->write((uint64_t*)&cgen_var_99, 1 * 8);
     vkStream->write((int32_t*)&forMarshaling->basePipelineIndex, sizeof(int32_t));
 }
 
@@ -2805,12 +2933,12 @@
     }
     vkStream->read((VkPipelineCreateFlags*)&forUnmarshaling->flags, sizeof(VkPipelineCreateFlags));
     unmarshal_VkPipelineShaderStageCreateInfo(vkStream, (VkPipelineShaderStageCreateInfo*)(&forUnmarshaling->stage));
-    uint64_t cgen_var_90;
-    vkStream->read((uint64_t*)&cgen_var_90, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_90, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
-    uint64_t cgen_var_91;
-    vkStream->read((uint64_t*)&cgen_var_91, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_91, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
+    uint64_t cgen_var_100;
+    vkStream->read((uint64_t*)&cgen_var_100, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_100, (VkPipelineLayout*)&forUnmarshaling->layout, 1);
+    uint64_t cgen_var_101;
+    vkStream->read((uint64_t*)&cgen_var_101, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_101, (VkPipeline*)&forUnmarshaling->basePipelineHandle, 1);
     vkStream->read((int32_t*)&forUnmarshaling->basePipelineIndex, sizeof(int32_t));
 }
 
@@ -2848,10 +2976,10 @@
     vkStream->write((uint32_t*)&forMarshaling->setLayoutCount, sizeof(uint32_t));
     if (forMarshaling->setLayoutCount)
     {
-        uint64_t* cgen_var_92;
-        vkStream->alloc((void**)&cgen_var_92, forMarshaling->setLayoutCount * 8);
-        vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_92, forMarshaling->setLayoutCount);
-        vkStream->write((uint64_t*)cgen_var_92, forMarshaling->setLayoutCount * 8);
+        uint64_t* cgen_var_102;
+        vkStream->alloc((void**)&cgen_var_102, forMarshaling->setLayoutCount * 8);
+        vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_102, forMarshaling->setLayoutCount);
+        vkStream->write((uint64_t*)cgen_var_102, forMarshaling->setLayoutCount * 8);
     }
     vkStream->write((uint32_t*)&forMarshaling->pushConstantRangeCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forMarshaling->pushConstantRangeCount; ++i)
@@ -2877,10 +3005,10 @@
     vkStream->read((uint32_t*)&forUnmarshaling->setLayoutCount, sizeof(uint32_t));
     if (forUnmarshaling->setLayoutCount)
     {
-        uint64_t* cgen_var_93;
-        vkStream->alloc((void**)&cgen_var_93, forUnmarshaling->setLayoutCount * 8);
-        vkStream->read((uint64_t*)cgen_var_93, forUnmarshaling->setLayoutCount * 8);
-        vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_93, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->setLayoutCount);
+        uint64_t* cgen_var_103;
+        vkStream->alloc((void**)&cgen_var_103, forUnmarshaling->setLayoutCount * 8);
+        vkStream->read((uint64_t*)cgen_var_103, forUnmarshaling->setLayoutCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_103, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->setLayoutCount);
     }
     vkStream->read((uint32_t*)&forUnmarshaling->pushConstantRangeCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->pushConstantRangeCount; ++i)
@@ -2959,16 +3087,16 @@
     vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
     vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
     // WARNING PTR CHECK
-    uint64_t cgen_var_94 = (uint64_t)(uintptr_t)forMarshaling->pImmutableSamplers;
-    vkStream->putBe64(cgen_var_94);
+    uint64_t cgen_var_104 = (uint64_t)(uintptr_t)forMarshaling->pImmutableSamplers;
+    vkStream->putBe64(cgen_var_104);
     if (forMarshaling->pImmutableSamplers)
     {
         if (forMarshaling->descriptorCount)
         {
-            uint64_t* cgen_var_95;
-            vkStream->alloc((void**)&cgen_var_95, forMarshaling->descriptorCount * 8);
-            vkStream->handleMapping()->mapHandles_VkSampler_u64(forMarshaling->pImmutableSamplers, cgen_var_95, forMarshaling->descriptorCount);
-            vkStream->write((uint64_t*)cgen_var_95, forMarshaling->descriptorCount * 8);
+            uint64_t* cgen_var_105;
+            vkStream->alloc((void**)&cgen_var_105, forMarshaling->descriptorCount * 8);
+            vkStream->handleMapping()->mapHandles_VkSampler_u64(forMarshaling->pImmutableSamplers, cgen_var_105, forMarshaling->descriptorCount);
+            vkStream->write((uint64_t*)cgen_var_105, forMarshaling->descriptorCount * 8);
         }
     }
 }
@@ -2992,10 +3120,10 @@
         }
         if (forUnmarshaling->descriptorCount)
         {
-            uint64_t* cgen_var_97;
-            vkStream->alloc((void**)&cgen_var_97, forUnmarshaling->descriptorCount * 8);
-            vkStream->read((uint64_t*)cgen_var_97, forUnmarshaling->descriptorCount * 8);
-            vkStream->handleMapping()->mapHandles_u64_VkSampler(cgen_var_97, (VkSampler*)forUnmarshaling->pImmutableSamplers, forUnmarshaling->descriptorCount);
+            uint64_t* cgen_var_107;
+            vkStream->alloc((void**)&cgen_var_107, forUnmarshaling->descriptorCount * 8);
+            vkStream->read((uint64_t*)cgen_var_107, forUnmarshaling->descriptorCount * 8);
+            vkStream->handleMapping()->mapHandles_u64_VkSampler(cgen_var_107, (VkSampler*)forUnmarshaling->pImmutableSamplers, forUnmarshaling->descriptorCount);
         }
     }
 }
@@ -3112,16 +3240,16 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_98;
-    vkStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&forMarshaling->descriptorPool, &cgen_var_98, 1);
-    vkStream->write((uint64_t*)&cgen_var_98, 1 * 8);
+    uint64_t cgen_var_108;
+    vkStream->handleMapping()->mapHandles_VkDescriptorPool_u64(&forMarshaling->descriptorPool, &cgen_var_108, 1);
+    vkStream->write((uint64_t*)&cgen_var_108, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->descriptorSetCount, sizeof(uint32_t));
     if (forMarshaling->descriptorSetCount)
     {
-        uint64_t* cgen_var_99;
-        vkStream->alloc((void**)&cgen_var_99, forMarshaling->descriptorSetCount * 8);
-        vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_99, forMarshaling->descriptorSetCount);
-        vkStream->write((uint64_t*)cgen_var_99, forMarshaling->descriptorSetCount * 8);
+        uint64_t* cgen_var_109;
+        vkStream->alloc((void**)&cgen_var_109, forMarshaling->descriptorSetCount * 8);
+        vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(forMarshaling->pSetLayouts, cgen_var_109, forMarshaling->descriptorSetCount);
+        vkStream->write((uint64_t*)cgen_var_109, forMarshaling->descriptorSetCount * 8);
     }
 }
 
@@ -3138,16 +3266,16 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_100;
-    vkStream->read((uint64_t*)&cgen_var_100, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_100, (VkDescriptorPool*)&forUnmarshaling->descriptorPool, 1);
+    uint64_t cgen_var_110;
+    vkStream->read((uint64_t*)&cgen_var_110, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDescriptorPool(&cgen_var_110, (VkDescriptorPool*)&forUnmarshaling->descriptorPool, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->descriptorSetCount, sizeof(uint32_t));
     if (forUnmarshaling->descriptorSetCount)
     {
-        uint64_t* cgen_var_101;
-        vkStream->alloc((void**)&cgen_var_101, forUnmarshaling->descriptorSetCount * 8);
-        vkStream->read((uint64_t*)cgen_var_101, forUnmarshaling->descriptorSetCount * 8);
-        vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_101, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->descriptorSetCount);
+        uint64_t* cgen_var_111;
+        vkStream->alloc((void**)&cgen_var_111, forUnmarshaling->descriptorSetCount * 8);
+        vkStream->read((uint64_t*)cgen_var_111, forUnmarshaling->descriptorSetCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(cgen_var_111, (VkDescriptorSetLayout*)forUnmarshaling->pSetLayouts, forUnmarshaling->descriptorSetCount);
     }
 }
 
@@ -3155,12 +3283,12 @@
     VulkanStreamGuest* vkStream,
     const VkDescriptorImageInfo* forMarshaling)
 {
-    uint64_t cgen_var_102;
-    vkStream->handleMapping()->mapHandles_VkSampler_u64(&forMarshaling->sampler, &cgen_var_102, 1);
-    vkStream->write((uint64_t*)&cgen_var_102, 1 * 8);
-    uint64_t cgen_var_103;
-    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_103, 1);
-    vkStream->write((uint64_t*)&cgen_var_103, 1 * 8);
+    uint64_t cgen_var_112;
+    vkStream->handleMapping()->mapHandles_VkSampler_u64(&forMarshaling->sampler, &cgen_var_112, 1);
+    vkStream->write((uint64_t*)&cgen_var_112, 1 * 8);
+    uint64_t cgen_var_113;
+    vkStream->handleMapping()->mapHandles_VkImageView_u64(&forMarshaling->imageView, &cgen_var_113, 1);
+    vkStream->write((uint64_t*)&cgen_var_113, 1 * 8);
     vkStream->write((VkImageLayout*)&forMarshaling->imageLayout, sizeof(VkImageLayout));
 }
 
@@ -3168,12 +3296,12 @@
     VulkanStreamGuest* vkStream,
     VkDescriptorImageInfo* forUnmarshaling)
 {
-    uint64_t cgen_var_104;
-    vkStream->read((uint64_t*)&cgen_var_104, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_104, (VkSampler*)&forUnmarshaling->sampler, 1);
-    uint64_t cgen_var_105;
-    vkStream->read((uint64_t*)&cgen_var_105, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_105, (VkImageView*)&forUnmarshaling->imageView, 1);
+    uint64_t cgen_var_114;
+    vkStream->read((uint64_t*)&cgen_var_114, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSampler(&cgen_var_114, (VkSampler*)&forUnmarshaling->sampler, 1);
+    uint64_t cgen_var_115;
+    vkStream->read((uint64_t*)&cgen_var_115, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImageView(&cgen_var_115, (VkImageView*)&forUnmarshaling->imageView, 1);
     vkStream->read((VkImageLayout*)&forUnmarshaling->imageLayout, sizeof(VkImageLayout));
 }
 
@@ -3181,9 +3309,9 @@
     VulkanStreamGuest* vkStream,
     const VkDescriptorBufferInfo* forMarshaling)
 {
-    uint64_t cgen_var_106;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_106, 1);
-    vkStream->write((uint64_t*)&cgen_var_106, 1 * 8);
+    uint64_t cgen_var_116;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_116, 1);
+    vkStream->write((uint64_t*)&cgen_var_116, 1 * 8);
     vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
     vkStream->write((VkDeviceSize*)&forMarshaling->range, sizeof(VkDeviceSize));
 }
@@ -3192,9 +3320,9 @@
     VulkanStreamGuest* vkStream,
     VkDescriptorBufferInfo* forUnmarshaling)
 {
-    uint64_t cgen_var_107;
-    vkStream->read((uint64_t*)&cgen_var_107, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_107, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    uint64_t cgen_var_117;
+    vkStream->read((uint64_t*)&cgen_var_117, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_117, (VkBuffer*)&forUnmarshaling->buffer, 1);
     vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
     vkStream->read((VkDeviceSize*)&forUnmarshaling->range, sizeof(VkDeviceSize));
 }
@@ -3211,19 +3339,19 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_108;
-    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_108, 1);
-    vkStream->write((uint64_t*)&cgen_var_108, 1 * 8);
+    uint64_t cgen_var_118;
+    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_118, 1);
+    vkStream->write((uint64_t*)&cgen_var_118, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
     vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
     // WARNING PTR CHECK
-    uint64_t cgen_var_109 = (uint64_t)(uintptr_t)forMarshaling->pImageInfo;
-    vkStream->putBe64(cgen_var_109);
+    uint64_t cgen_var_119 = (uint64_t)(uintptr_t)forMarshaling->pImageInfo;
+    vkStream->putBe64(cgen_var_119);
     if (forMarshaling->pImageInfo)
     {
-        if ((VK_DESCRIPTOR_TYPE_SAMPLER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forMarshaling->descriptorType))
+        if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_SAMPLER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forMarshaling->descriptorType))))
         {
             for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
             {
@@ -3232,11 +3360,11 @@
         }
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_110 = (uint64_t)(uintptr_t)forMarshaling->pBufferInfo;
-    vkStream->putBe64(cgen_var_110);
+    uint64_t cgen_var_120 = (uint64_t)(uintptr_t)forMarshaling->pBufferInfo;
+    vkStream->putBe64(cgen_var_120);
     if (forMarshaling->pBufferInfo)
     {
-        if ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forMarshaling->descriptorType))
+        if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forMarshaling->descriptorType))))
         {
             for (uint32_t i = 0; i < (uint32_t)forMarshaling->descriptorCount; ++i)
             {
@@ -3245,18 +3373,18 @@
         }
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_111 = (uint64_t)(uintptr_t)forMarshaling->pTexelBufferView;
-    vkStream->putBe64(cgen_var_111);
+    uint64_t cgen_var_121 = (uint64_t)(uintptr_t)forMarshaling->pTexelBufferView;
+    vkStream->putBe64(cgen_var_121);
     if (forMarshaling->pTexelBufferView)
     {
-        if ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forMarshaling->descriptorType))
+        if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forMarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forMarshaling->descriptorType))))
         {
             if (forMarshaling->descriptorCount)
             {
-                uint64_t* cgen_var_112;
-                vkStream->alloc((void**)&cgen_var_112, forMarshaling->descriptorCount * 8);
-                vkStream->handleMapping()->mapHandles_VkBufferView_u64(forMarshaling->pTexelBufferView, cgen_var_112, forMarshaling->descriptorCount);
-                vkStream->write((uint64_t*)cgen_var_112, forMarshaling->descriptorCount * 8);
+                uint64_t* cgen_var_122;
+                vkStream->alloc((void**)&cgen_var_122, forMarshaling->descriptorCount * 8);
+                vkStream->handleMapping()->mapHandles_VkBufferView_u64(forMarshaling->pTexelBufferView, cgen_var_122, forMarshaling->descriptorCount);
+                vkStream->write((uint64_t*)cgen_var_122, forMarshaling->descriptorCount * 8);
             }
         }
     }
@@ -3275,9 +3403,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_113;
-    vkStream->read((uint64_t*)&cgen_var_113, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_113, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
+    uint64_t cgen_var_123;
+    vkStream->read((uint64_t*)&cgen_var_123, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_123, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
     vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
     vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
@@ -3291,7 +3419,7 @@
         {
             fprintf(stderr, "fatal: forUnmarshaling->pImageInfo inconsistent between guest and host\n");
         }
-        if ((VK_DESCRIPTOR_TYPE_SAMPLER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forUnmarshaling->descriptorType))
+        if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_SAMPLER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_IMAGE == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT == forUnmarshaling->descriptorType))))
         {
             for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i)
             {
@@ -3312,7 +3440,7 @@
         {
             fprintf(stderr, "fatal: forUnmarshaling->pBufferInfo inconsistent between guest and host\n");
         }
-        if ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forUnmarshaling->descriptorType))
+        if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC == forUnmarshaling->descriptorType))))
         {
             for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->descriptorCount; ++i)
             {
@@ -3333,14 +3461,14 @@
         {
             fprintf(stderr, "fatal: forUnmarshaling->pTexelBufferView inconsistent between guest and host\n");
         }
-        if ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forUnmarshaling->descriptorType))
+        if ((!(vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT) || ((VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER == forUnmarshaling->descriptorType) || (VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER == forUnmarshaling->descriptorType))))
         {
             if (forUnmarshaling->descriptorCount)
             {
-                uint64_t* cgen_var_117;
-                vkStream->alloc((void**)&cgen_var_117, forUnmarshaling->descriptorCount * 8);
-                vkStream->read((uint64_t*)cgen_var_117, forUnmarshaling->descriptorCount * 8);
-                vkStream->handleMapping()->mapHandles_u64_VkBufferView(cgen_var_117, (VkBufferView*)forUnmarshaling->pTexelBufferView, forUnmarshaling->descriptorCount);
+                uint64_t* cgen_var_127;
+                vkStream->alloc((void**)&cgen_var_127, forUnmarshaling->descriptorCount * 8);
+                vkStream->read((uint64_t*)cgen_var_127, forUnmarshaling->descriptorCount * 8);
+                vkStream->handleMapping()->mapHandles_u64_VkBufferView(cgen_var_127, (VkBufferView*)forUnmarshaling->pTexelBufferView, forUnmarshaling->descriptorCount);
             }
         }
         else
@@ -3362,14 +3490,14 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_118;
-    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->srcSet, &cgen_var_118, 1);
-    vkStream->write((uint64_t*)&cgen_var_118, 1 * 8);
+    uint64_t cgen_var_128;
+    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->srcSet, &cgen_var_128, 1);
+    vkStream->write((uint64_t*)&cgen_var_128, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->srcBinding, sizeof(uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->srcArrayElement, sizeof(uint32_t));
-    uint64_t cgen_var_119;
-    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_119, 1);
-    vkStream->write((uint64_t*)&cgen_var_119, 1 * 8);
+    uint64_t cgen_var_129;
+    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->dstSet, &cgen_var_129, 1);
+    vkStream->write((uint64_t*)&cgen_var_129, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->dstBinding, sizeof(uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
@@ -3388,14 +3516,14 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_120;
-    vkStream->read((uint64_t*)&cgen_var_120, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_120, (VkDescriptorSet*)&forUnmarshaling->srcSet, 1);
+    uint64_t cgen_var_130;
+    vkStream->read((uint64_t*)&cgen_var_130, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_130, (VkDescriptorSet*)&forUnmarshaling->srcSet, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->srcBinding, sizeof(uint32_t));
     vkStream->read((uint32_t*)&forUnmarshaling->srcArrayElement, sizeof(uint32_t));
-    uint64_t cgen_var_121;
-    vkStream->read((uint64_t*)&cgen_var_121, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_121, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
+    uint64_t cgen_var_131;
+    vkStream->read((uint64_t*)&cgen_var_131, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_131, (VkDescriptorSet*)&forUnmarshaling->dstSet, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->dstBinding, sizeof(uint32_t));
     vkStream->read((uint32_t*)&forUnmarshaling->dstArrayElement, sizeof(uint32_t));
     vkStream->read((uint32_t*)&forUnmarshaling->descriptorCount, sizeof(uint32_t));
@@ -3414,16 +3542,16 @@
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
     vkStream->write((VkFramebufferCreateFlags*)&forMarshaling->flags, sizeof(VkFramebufferCreateFlags));
-    uint64_t cgen_var_122;
-    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_122, 1);
-    vkStream->write((uint64_t*)&cgen_var_122, 1 * 8);
+    uint64_t cgen_var_132;
+    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_132, 1);
+    vkStream->write((uint64_t*)&cgen_var_132, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->attachmentCount, sizeof(uint32_t));
     if (forMarshaling->attachmentCount)
     {
-        uint64_t* cgen_var_123;
-        vkStream->alloc((void**)&cgen_var_123, forMarshaling->attachmentCount * 8);
-        vkStream->handleMapping()->mapHandles_VkImageView_u64(forMarshaling->pAttachments, cgen_var_123, forMarshaling->attachmentCount);
-        vkStream->write((uint64_t*)cgen_var_123, forMarshaling->attachmentCount * 8);
+        uint64_t* cgen_var_133;
+        vkStream->alloc((void**)&cgen_var_133, forMarshaling->attachmentCount * 8);
+        vkStream->handleMapping()->mapHandles_VkImageView_u64(forMarshaling->pAttachments, cgen_var_133, forMarshaling->attachmentCount);
+        vkStream->write((uint64_t*)cgen_var_133, forMarshaling->attachmentCount * 8);
     }
     vkStream->write((uint32_t*)&forMarshaling->width, sizeof(uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->height, sizeof(uint32_t));
@@ -3444,16 +3572,16 @@
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
     vkStream->read((VkFramebufferCreateFlags*)&forUnmarshaling->flags, sizeof(VkFramebufferCreateFlags));
-    uint64_t cgen_var_124;
-    vkStream->read((uint64_t*)&cgen_var_124, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_124, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+    uint64_t cgen_var_134;
+    vkStream->read((uint64_t*)&cgen_var_134, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_134, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->attachmentCount, sizeof(uint32_t));
     if (forUnmarshaling->attachmentCount)
     {
-        uint64_t* cgen_var_125;
-        vkStream->alloc((void**)&cgen_var_125, forUnmarshaling->attachmentCount * 8);
-        vkStream->read((uint64_t*)cgen_var_125, forUnmarshaling->attachmentCount * 8);
-        vkStream->handleMapping()->mapHandles_u64_VkImageView(cgen_var_125, (VkImageView*)forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount);
+        uint64_t* cgen_var_135;
+        vkStream->alloc((void**)&cgen_var_135, forUnmarshaling->attachmentCount * 8);
+        vkStream->read((uint64_t*)cgen_var_135, forUnmarshaling->attachmentCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkImageView(cgen_var_135, (VkImageView*)forUnmarshaling->pAttachments, forUnmarshaling->attachmentCount);
     }
     vkStream->read((uint32_t*)&forUnmarshaling->width, sizeof(uint32_t));
     vkStream->read((uint32_t*)&forUnmarshaling->height, sizeof(uint32_t));
@@ -3523,8 +3651,8 @@
         marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pColorAttachments + i));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_126 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
-    vkStream->putBe64(cgen_var_126);
+    uint64_t cgen_var_136 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
+    vkStream->putBe64(cgen_var_136);
     if (forMarshaling->pResolveAttachments)
     {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
@@ -3533,8 +3661,8 @@
         }
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_127 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
-    vkStream->putBe64(cgen_var_127);
+    uint64_t cgen_var_137 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
+    vkStream->putBe64(cgen_var_137);
     if (forMarshaling->pDepthStencilAttachment)
     {
         marshal_VkAttachmentReference(vkStream, (const VkAttachmentReference*)(forMarshaling->pDepthStencilAttachment));
@@ -3720,9 +3848,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_130;
-    vkStream->handleMapping()->mapHandles_VkCommandPool_u64(&forMarshaling->commandPool, &cgen_var_130, 1);
-    vkStream->write((uint64_t*)&cgen_var_130, 1 * 8);
+    uint64_t cgen_var_140;
+    vkStream->handleMapping()->mapHandles_VkCommandPool_u64(&forMarshaling->commandPool, &cgen_var_140, 1);
+    vkStream->write((uint64_t*)&cgen_var_140, 1 * 8);
     vkStream->write((VkCommandBufferLevel*)&forMarshaling->level, sizeof(VkCommandBufferLevel));
     vkStream->write((uint32_t*)&forMarshaling->commandBufferCount, sizeof(uint32_t));
 }
@@ -3740,9 +3868,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_131;
-    vkStream->read((uint64_t*)&cgen_var_131, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_131, (VkCommandPool*)&forUnmarshaling->commandPool, 1);
+    uint64_t cgen_var_141;
+    vkStream->read((uint64_t*)&cgen_var_141, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkCommandPool(&cgen_var_141, (VkCommandPool*)&forUnmarshaling->commandPool, 1);
     vkStream->read((VkCommandBufferLevel*)&forUnmarshaling->level, sizeof(VkCommandBufferLevel));
     vkStream->read((uint32_t*)&forUnmarshaling->commandBufferCount, sizeof(uint32_t));
 }
@@ -3759,13 +3887,13 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_132;
-    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_132, 1);
-    vkStream->write((uint64_t*)&cgen_var_132, 1 * 8);
+    uint64_t cgen_var_142;
+    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_142, 1);
+    vkStream->write((uint64_t*)&cgen_var_142, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->subpass, sizeof(uint32_t));
-    uint64_t cgen_var_133;
-    vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_133, 1);
-    vkStream->write((uint64_t*)&cgen_var_133, 1 * 8);
+    uint64_t cgen_var_143;
+    vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_143, 1);
+    vkStream->write((uint64_t*)&cgen_var_143, 1 * 8);
     vkStream->write((VkBool32*)&forMarshaling->occlusionQueryEnable, sizeof(VkBool32));
     vkStream->write((VkQueryControlFlags*)&forMarshaling->queryFlags, sizeof(VkQueryControlFlags));
     vkStream->write((VkQueryPipelineStatisticFlags*)&forMarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
@@ -3784,13 +3912,13 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_134;
-    vkStream->read((uint64_t*)&cgen_var_134, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_134, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+    uint64_t cgen_var_144;
+    vkStream->read((uint64_t*)&cgen_var_144, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_144, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->subpass, sizeof(uint32_t));
-    uint64_t cgen_var_135;
-    vkStream->read((uint64_t*)&cgen_var_135, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_135, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
+    uint64_t cgen_var_145;
+    vkStream->read((uint64_t*)&cgen_var_145, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_145, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
     vkStream->read((VkBool32*)&forUnmarshaling->occlusionQueryEnable, sizeof(VkBool32));
     vkStream->read((VkQueryControlFlags*)&forUnmarshaling->queryFlags, sizeof(VkQueryControlFlags));
     vkStream->read((VkQueryPipelineStatisticFlags*)&forUnmarshaling->pipelineStatistics, sizeof(VkQueryPipelineStatisticFlags));
@@ -3810,8 +3938,8 @@
     }
     vkStream->write((VkCommandBufferUsageFlags*)&forMarshaling->flags, sizeof(VkCommandBufferUsageFlags));
     // WARNING PTR CHECK
-    uint64_t cgen_var_136 = (uint64_t)(uintptr_t)forMarshaling->pInheritanceInfo;
-    vkStream->putBe64(cgen_var_136);
+    uint64_t cgen_var_146 = (uint64_t)(uintptr_t)forMarshaling->pInheritanceInfo;
+    vkStream->putBe64(cgen_var_146);
     if (forMarshaling->pInheritanceInfo)
     {
         marshal_VkCommandBufferInheritanceInfo(vkStream, (const VkCommandBufferInheritanceInfo*)(forMarshaling->pInheritanceInfo));
@@ -4112,9 +4240,9 @@
     vkStream->write((VkAccessFlags*)&forMarshaling->dstAccessMask, sizeof(VkAccessFlags));
     vkStream->write((uint32_t*)&forMarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
-    uint64_t cgen_var_138;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_138, 1);
-    vkStream->write((uint64_t*)&cgen_var_138, 1 * 8);
+    uint64_t cgen_var_148;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_148, 1);
+    vkStream->write((uint64_t*)&cgen_var_148, 1 * 8);
     vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
     vkStream->write((VkDeviceSize*)&forMarshaling->size, sizeof(VkDeviceSize));
 }
@@ -4136,9 +4264,9 @@
     vkStream->read((VkAccessFlags*)&forUnmarshaling->dstAccessMask, sizeof(VkAccessFlags));
     vkStream->read((uint32_t*)&forUnmarshaling->srcQueueFamilyIndex, sizeof(uint32_t));
     vkStream->read((uint32_t*)&forUnmarshaling->dstQueueFamilyIndex, sizeof(uint32_t));
-    uint64_t cgen_var_139;
-    vkStream->read((uint64_t*)&cgen_var_139, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_139, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    uint64_t cgen_var_149;
+    vkStream->read((uint64_t*)&cgen_var_149, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_149, (VkBuffer*)&forUnmarshaling->buffer, 1);
     vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
     vkStream->read((VkDeviceSize*)&forUnmarshaling->size, sizeof(VkDeviceSize));
 }
@@ -4161,9 +4289,9 @@
     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_140;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_140, 1);
-    vkStream->write((uint64_t*)&cgen_var_140, 1 * 8);
+    uint64_t cgen_var_150;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_150, 1);
+    vkStream->write((uint64_t*)&cgen_var_150, 1 * 8);
     marshal_VkImageSubresourceRange(vkStream, (VkImageSubresourceRange*)(&forMarshaling->subresourceRange));
 }
 
@@ -4186,9 +4314,9 @@
     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_141;
-    vkStream->read((uint64_t*)&cgen_var_141, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_141, (VkImage*)&forUnmarshaling->image, 1);
+    uint64_t cgen_var_151;
+    vkStream->read((uint64_t*)&cgen_var_151, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_151, (VkImage*)&forUnmarshaling->image, 1);
     unmarshal_VkImageSubresourceRange(vkStream, (VkImageSubresourceRange*)(&forUnmarshaling->subresourceRange));
 }
 
@@ -4204,17 +4332,17 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_142;
-    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_142, 1);
-    vkStream->write((uint64_t*)&cgen_var_142, 1 * 8);
-    uint64_t cgen_var_143;
-    vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_143, 1);
-    vkStream->write((uint64_t*)&cgen_var_143, 1 * 8);
+    uint64_t cgen_var_152;
+    vkStream->handleMapping()->mapHandles_VkRenderPass_u64(&forMarshaling->renderPass, &cgen_var_152, 1);
+    vkStream->write((uint64_t*)&cgen_var_152, 1 * 8);
+    uint64_t cgen_var_153;
+    vkStream->handleMapping()->mapHandles_VkFramebuffer_u64(&forMarshaling->framebuffer, &cgen_var_153, 1);
+    vkStream->write((uint64_t*)&cgen_var_153, 1 * 8);
     marshal_VkRect2D(vkStream, (VkRect2D*)(&forMarshaling->renderArea));
     vkStream->write((uint32_t*)&forMarshaling->clearValueCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_144 = (uint64_t)(uintptr_t)forMarshaling->pClearValues;
-    vkStream->putBe64(cgen_var_144);
+    uint64_t cgen_var_154 = (uint64_t)(uintptr_t)forMarshaling->pClearValues;
+    vkStream->putBe64(cgen_var_154);
     if (forMarshaling->pClearValues)
     {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->clearValueCount; ++i)
@@ -4237,12 +4365,12 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_145;
-    vkStream->read((uint64_t*)&cgen_var_145, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_145, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
-    uint64_t cgen_var_146;
-    vkStream->read((uint64_t*)&cgen_var_146, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_146, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
+    uint64_t cgen_var_155;
+    vkStream->read((uint64_t*)&cgen_var_155, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkRenderPass(&cgen_var_155, (VkRenderPass*)&forUnmarshaling->renderPass, 1);
+    uint64_t cgen_var_156;
+    vkStream->read((uint64_t*)&cgen_var_156, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkFramebuffer(&cgen_var_156, (VkFramebuffer*)&forUnmarshaling->framebuffer, 1);
     unmarshal_VkRect2D(vkStream, (VkRect2D*)(&forUnmarshaling->renderArea));
     vkStream->read((uint32_t*)&forUnmarshaling->clearValueCount, sizeof(uint32_t));
     // WARNING PTR CHECK
@@ -4430,12 +4558,12 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_148;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_148, 1);
-    vkStream->write((uint64_t*)&cgen_var_148, 1 * 8);
-    uint64_t cgen_var_149;
-    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_149, 1);
-    vkStream->write((uint64_t*)&cgen_var_149, 1 * 8);
+    uint64_t cgen_var_158;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_158, 1);
+    vkStream->write((uint64_t*)&cgen_var_158, 1 * 8);
+    uint64_t cgen_var_159;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_159, 1);
+    vkStream->write((uint64_t*)&cgen_var_159, 1 * 8);
     vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
 }
 
@@ -4452,12 +4580,12 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_150;
-    vkStream->read((uint64_t*)&cgen_var_150, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_150, (VkBuffer*)&forUnmarshaling->buffer, 1);
-    uint64_t cgen_var_151;
-    vkStream->read((uint64_t*)&cgen_var_151, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_151, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+    uint64_t cgen_var_160;
+    vkStream->read((uint64_t*)&cgen_var_160, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_160, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    uint64_t cgen_var_161;
+    vkStream->read((uint64_t*)&cgen_var_161, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_161, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
     vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
 }
 
@@ -4473,12 +4601,12 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_152;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_152, 1);
-    vkStream->write((uint64_t*)&cgen_var_152, 1 * 8);
-    uint64_t cgen_var_153;
-    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_153, 1);
-    vkStream->write((uint64_t*)&cgen_var_153, 1 * 8);
+    uint64_t cgen_var_162;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_162, 1);
+    vkStream->write((uint64_t*)&cgen_var_162, 1 * 8);
+    uint64_t cgen_var_163;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_163, 1);
+    vkStream->write((uint64_t*)&cgen_var_163, 1 * 8);
     vkStream->write((VkDeviceSize*)&forMarshaling->memoryOffset, sizeof(VkDeviceSize));
 }
 
@@ -4495,12 +4623,12 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_154;
-    vkStream->read((uint64_t*)&cgen_var_154, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_154, (VkImage*)&forUnmarshaling->image, 1);
-    uint64_t cgen_var_155;
-    vkStream->read((uint64_t*)&cgen_var_155, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_155, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+    uint64_t cgen_var_164;
+    vkStream->read((uint64_t*)&cgen_var_164, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_164, (VkImage*)&forUnmarshaling->image, 1);
+    uint64_t cgen_var_165;
+    vkStream->read((uint64_t*)&cgen_var_165, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_165, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
     vkStream->read((VkDeviceSize*)&forUnmarshaling->memoryOffset, sizeof(VkDeviceSize));
 }
 
@@ -4586,12 +4714,12 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_156;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_156, 1);
-    vkStream->write((uint64_t*)&cgen_var_156, 1 * 8);
-    uint64_t cgen_var_157;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_157, 1);
-    vkStream->write((uint64_t*)&cgen_var_157, 1 * 8);
+    uint64_t cgen_var_166;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_166, 1);
+    vkStream->write((uint64_t*)&cgen_var_166, 1 * 8);
+    uint64_t cgen_var_167;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_167, 1);
+    vkStream->write((uint64_t*)&cgen_var_167, 1 * 8);
 }
 
 void unmarshal_VkMemoryDedicatedAllocateInfo(
@@ -4607,12 +4735,12 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_158;
-    vkStream->read((uint64_t*)&cgen_var_158, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_158, (VkImage*)&forUnmarshaling->image, 1);
-    uint64_t cgen_var_159;
-    vkStream->read((uint64_t*)&cgen_var_159, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_159, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    uint64_t cgen_var_168;
+    vkStream->read((uint64_t*)&cgen_var_168, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_168, (VkImage*)&forUnmarshaling->image, 1);
+    uint64_t cgen_var_169;
+    vkStream->read((uint64_t*)&cgen_var_169, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_169, (VkBuffer*)&forUnmarshaling->buffer, 1);
 }
 
 void marshal_VkMemoryAllocateFlagsInfo(
@@ -4920,10 +5048,10 @@
     vkStream->write((uint32_t*)&forMarshaling->physicalDeviceCount, sizeof(uint32_t));
     if (forMarshaling->physicalDeviceCount)
     {
-        uint64_t* cgen_var_160;
-        vkStream->alloc((void**)&cgen_var_160, forMarshaling->physicalDeviceCount * 8);
-        vkStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(forMarshaling->pPhysicalDevices, cgen_var_160, forMarshaling->physicalDeviceCount);
-        vkStream->write((uint64_t*)cgen_var_160, forMarshaling->physicalDeviceCount * 8);
+        uint64_t* cgen_var_170;
+        vkStream->alloc((void**)&cgen_var_170, forMarshaling->physicalDeviceCount * 8);
+        vkStream->handleMapping()->mapHandles_VkPhysicalDevice_u64(forMarshaling->pPhysicalDevices, cgen_var_170, forMarshaling->physicalDeviceCount);
+        vkStream->write((uint64_t*)cgen_var_170, forMarshaling->physicalDeviceCount * 8);
     }
 }
 
@@ -4943,10 +5071,10 @@
     vkStream->read((uint32_t*)&forUnmarshaling->physicalDeviceCount, sizeof(uint32_t));
     if (forUnmarshaling->physicalDeviceCount)
     {
-        uint64_t* cgen_var_161;
-        vkStream->alloc((void**)&cgen_var_161, forUnmarshaling->physicalDeviceCount * 8);
-        vkStream->read((uint64_t*)cgen_var_161, forUnmarshaling->physicalDeviceCount * 8);
-        vkStream->handleMapping()->mapHandles_u64_VkPhysicalDevice(cgen_var_161, (VkPhysicalDevice*)forUnmarshaling->pPhysicalDevices, forUnmarshaling->physicalDeviceCount);
+        uint64_t* cgen_var_171;
+        vkStream->alloc((void**)&cgen_var_171, forUnmarshaling->physicalDeviceCount * 8);
+        vkStream->read((uint64_t*)cgen_var_171, forUnmarshaling->physicalDeviceCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkPhysicalDevice(cgen_var_171, (VkPhysicalDevice*)forUnmarshaling->pPhysicalDevices, forUnmarshaling->physicalDeviceCount);
     }
 }
 
@@ -4962,9 +5090,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_162;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_162, 1);
-    vkStream->write((uint64_t*)&cgen_var_162, 1 * 8);
+    uint64_t cgen_var_172;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_172, 1);
+    vkStream->write((uint64_t*)&cgen_var_172, 1 * 8);
 }
 
 void unmarshal_VkBufferMemoryRequirementsInfo2(
@@ -4980,9 +5108,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_163;
-    vkStream->read((uint64_t*)&cgen_var_163, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_163, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    uint64_t cgen_var_173;
+    vkStream->read((uint64_t*)&cgen_var_173, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_173, (VkBuffer*)&forUnmarshaling->buffer, 1);
 }
 
 void marshal_VkImageMemoryRequirementsInfo2(
@@ -4997,9 +5125,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_164;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_164, 1);
-    vkStream->write((uint64_t*)&cgen_var_164, 1 * 8);
+    uint64_t cgen_var_174;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_174, 1);
+    vkStream->write((uint64_t*)&cgen_var_174, 1 * 8);
 }
 
 void unmarshal_VkImageMemoryRequirementsInfo2(
@@ -5015,9 +5143,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_165;
-    vkStream->read((uint64_t*)&cgen_var_165, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_165, (VkImage*)&forUnmarshaling->image, 1);
+    uint64_t cgen_var_175;
+    vkStream->read((uint64_t*)&cgen_var_175, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_175, (VkImage*)&forUnmarshaling->image, 1);
 }
 
 void marshal_VkImageSparseMemoryRequirementsInfo2(
@@ -5032,9 +5160,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_166;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_166, 1);
-    vkStream->write((uint64_t*)&cgen_var_166, 1 * 8);
+    uint64_t cgen_var_176;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_176, 1);
+    vkStream->write((uint64_t*)&cgen_var_176, 1 * 8);
 }
 
 void unmarshal_VkImageSparseMemoryRequirementsInfo2(
@@ -5050,9 +5178,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_167;
-    vkStream->read((uint64_t*)&cgen_var_167, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_167, (VkImage*)&forUnmarshaling->image, 1);
+    uint64_t cgen_var_177;
+    vkStream->read((uint64_t*)&cgen_var_177, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_177, (VkImage*)&forUnmarshaling->image, 1);
 }
 
 void marshal_VkMemoryRequirements2(
@@ -5889,9 +6017,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_168;
-    vkStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&forMarshaling->conversion, &cgen_var_168, 1);
-    vkStream->write((uint64_t*)&cgen_var_168, 1 * 8);
+    uint64_t cgen_var_178;
+    vkStream->handleMapping()->mapHandles_VkSamplerYcbcrConversion_u64(&forMarshaling->conversion, &cgen_var_178, 1);
+    vkStream->write((uint64_t*)&cgen_var_178, 1 * 8);
 }
 
 void unmarshal_VkSamplerYcbcrConversionInfo(
@@ -5907,9 +6035,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_169;
-    vkStream->read((uint64_t*)&cgen_var_169, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_169, (VkSamplerYcbcrConversion*)&forUnmarshaling->conversion, 1);
+    uint64_t cgen_var_179;
+    vkStream->read((uint64_t*)&cgen_var_179, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSamplerYcbcrConversion(&cgen_var_179, (VkSamplerYcbcrConversion*)&forUnmarshaling->conversion, 1);
 }
 
 void marshal_VkBindImagePlaneMemoryInfo(
@@ -6044,10 +6172,10 @@
     vkStream->write((uint32_t*)&forMarshaling->dstArrayElement, sizeof(uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->descriptorCount, sizeof(uint32_t));
     vkStream->write((VkDescriptorType*)&forMarshaling->descriptorType, sizeof(VkDescriptorType));
-    uint64_t cgen_var_170 = (uint64_t)forMarshaling->offset;
-    vkStream->putBe64(cgen_var_170);
-    uint64_t cgen_var_171 = (uint64_t)forMarshaling->stride;
-    vkStream->putBe64(cgen_var_171);
+    uint64_t cgen_var_180 = (uint64_t)forMarshaling->offset;
+    vkStream->putBe64(cgen_var_180);
+    uint64_t cgen_var_181 = (uint64_t)forMarshaling->stride;
+    vkStream->putBe64(cgen_var_181);
 }
 
 void unmarshal_VkDescriptorUpdateTemplateEntry(
@@ -6081,13 +6209,13 @@
         marshal_VkDescriptorUpdateTemplateEntry(vkStream, (const VkDescriptorUpdateTemplateEntry*)(forMarshaling->pDescriptorUpdateEntries + i));
     }
     vkStream->write((VkDescriptorUpdateTemplateType*)&forMarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
-    uint64_t cgen_var_174;
-    vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&forMarshaling->descriptorSetLayout, &cgen_var_174, 1);
-    vkStream->write((uint64_t*)&cgen_var_174, 1 * 8);
+    uint64_t cgen_var_184;
+    vkStream->handleMapping()->mapHandles_VkDescriptorSetLayout_u64(&forMarshaling->descriptorSetLayout, &cgen_var_184, 1);
+    vkStream->write((uint64_t*)&cgen_var_184, 1 * 8);
     vkStream->write((VkPipelineBindPoint*)&forMarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
-    uint64_t cgen_var_175;
-    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_175, 1);
-    vkStream->write((uint64_t*)&cgen_var_175, 1 * 8);
+    uint64_t cgen_var_185;
+    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_185, 1);
+    vkStream->write((uint64_t*)&cgen_var_185, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->set, sizeof(uint32_t));
 }
 
@@ -6111,13 +6239,13 @@
         unmarshal_VkDescriptorUpdateTemplateEntry(vkStream, (VkDescriptorUpdateTemplateEntry*)(forUnmarshaling->pDescriptorUpdateEntries + i));
     }
     vkStream->read((VkDescriptorUpdateTemplateType*)&forUnmarshaling->templateType, sizeof(VkDescriptorUpdateTemplateType));
-    uint64_t cgen_var_176;
-    vkStream->read((uint64_t*)&cgen_var_176, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_176, (VkDescriptorSetLayout*)&forUnmarshaling->descriptorSetLayout, 1);
+    uint64_t cgen_var_186;
+    vkStream->read((uint64_t*)&cgen_var_186, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSetLayout(&cgen_var_186, (VkDescriptorSetLayout*)&forUnmarshaling->descriptorSetLayout, 1);
     vkStream->read((VkPipelineBindPoint*)&forUnmarshaling->pipelineBindPoint, sizeof(VkPipelineBindPoint));
-    uint64_t cgen_var_177;
-    vkStream->read((uint64_t*)&cgen_var_177, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_177, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+    uint64_t cgen_var_187;
+    vkStream->read((uint64_t*)&cgen_var_187, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_187, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->set, sizeof(uint32_t));
 }
 
@@ -6753,9 +6881,9 @@
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
     vkStream->write((VkSwapchainCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
-    uint64_t cgen_var_178;
-    vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_178, 1);
-    vkStream->write((uint64_t*)&cgen_var_178, 1 * 8);
+    uint64_t cgen_var_188;
+    vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_188, 1);
+    vkStream->write((uint64_t*)&cgen_var_188, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->minImageCount, sizeof(uint32_t));
     vkStream->write((VkFormat*)&forMarshaling->imageFormat, sizeof(VkFormat));
     vkStream->write((VkColorSpaceKHR*)&forMarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
@@ -6765,8 +6893,8 @@
     vkStream->write((VkSharingMode*)&forMarshaling->imageSharingMode, sizeof(VkSharingMode));
     vkStream->write((uint32_t*)&forMarshaling->queueFamilyIndexCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_179 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
-    vkStream->putBe64(cgen_var_179);
+    uint64_t cgen_var_189 = (uint64_t)(uintptr_t)forMarshaling->pQueueFamilyIndices;
+    vkStream->putBe64(cgen_var_189);
     if (forMarshaling->pQueueFamilyIndices)
     {
         vkStream->write((const uint32_t*)forMarshaling->pQueueFamilyIndices, forMarshaling->queueFamilyIndexCount * sizeof(const uint32_t));
@@ -6775,9 +6903,9 @@
     vkStream->write((VkCompositeAlphaFlagBitsKHR*)&forMarshaling->compositeAlpha, sizeof(VkCompositeAlphaFlagBitsKHR));
     vkStream->write((VkPresentModeKHR*)&forMarshaling->presentMode, sizeof(VkPresentModeKHR));
     vkStream->write((VkBool32*)&forMarshaling->clipped, sizeof(VkBool32));
-    uint64_t cgen_var_180;
-    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->oldSwapchain, &cgen_var_180, 1);
-    vkStream->write((uint64_t*)&cgen_var_180, 1 * 8);
+    uint64_t cgen_var_190;
+    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->oldSwapchain, &cgen_var_190, 1);
+    vkStream->write((uint64_t*)&cgen_var_190, 1 * 8);
 }
 
 void unmarshal_VkSwapchainCreateInfoKHR(
@@ -6794,9 +6922,9 @@
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
     vkStream->read((VkSwapchainCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkSwapchainCreateFlagsKHR));
-    uint64_t cgen_var_181;
-    vkStream->read((uint64_t*)&cgen_var_181, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_181, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
+    uint64_t cgen_var_191;
+    vkStream->read((uint64_t*)&cgen_var_191, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_191, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->minImageCount, sizeof(uint32_t));
     vkStream->read((VkFormat*)&forUnmarshaling->imageFormat, sizeof(VkFormat));
     vkStream->read((VkColorSpaceKHR*)&forUnmarshaling->imageColorSpace, sizeof(VkColorSpaceKHR));
@@ -6820,9 +6948,9 @@
     vkStream->read((VkCompositeAlphaFlagBitsKHR*)&forUnmarshaling->compositeAlpha, sizeof(VkCompositeAlphaFlagBitsKHR));
     vkStream->read((VkPresentModeKHR*)&forUnmarshaling->presentMode, sizeof(VkPresentModeKHR));
     vkStream->read((VkBool32*)&forUnmarshaling->clipped, sizeof(VkBool32));
-    uint64_t cgen_var_183;
-    vkStream->read((uint64_t*)&cgen_var_183, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_183, (VkSwapchainKHR*)&forUnmarshaling->oldSwapchain, 1);
+    uint64_t cgen_var_193;
+    vkStream->read((uint64_t*)&cgen_var_193, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_193, (VkSwapchainKHR*)&forUnmarshaling->oldSwapchain, 1);
 }
 
 void marshal_VkPresentInfoKHR(
@@ -6840,23 +6968,23 @@
     vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreCount, sizeof(uint32_t));
     if (forMarshaling->waitSemaphoreCount)
     {
-        uint64_t* cgen_var_184;
-        vkStream->alloc((void**)&cgen_var_184, forMarshaling->waitSemaphoreCount * 8);
-        vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_184, forMarshaling->waitSemaphoreCount);
-        vkStream->write((uint64_t*)cgen_var_184, forMarshaling->waitSemaphoreCount * 8);
+        uint64_t* cgen_var_194;
+        vkStream->alloc((void**)&cgen_var_194, forMarshaling->waitSemaphoreCount * 8);
+        vkStream->handleMapping()->mapHandles_VkSemaphore_u64(forMarshaling->pWaitSemaphores, cgen_var_194, forMarshaling->waitSemaphoreCount);
+        vkStream->write((uint64_t*)cgen_var_194, forMarshaling->waitSemaphoreCount * 8);
     }
     vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
     if (forMarshaling->swapchainCount)
     {
-        uint64_t* cgen_var_185;
-        vkStream->alloc((void**)&cgen_var_185, forMarshaling->swapchainCount * 8);
-        vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(forMarshaling->pSwapchains, cgen_var_185, forMarshaling->swapchainCount);
-        vkStream->write((uint64_t*)cgen_var_185, forMarshaling->swapchainCount * 8);
+        uint64_t* cgen_var_195;
+        vkStream->alloc((void**)&cgen_var_195, forMarshaling->swapchainCount * 8);
+        vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(forMarshaling->pSwapchains, cgen_var_195, forMarshaling->swapchainCount);
+        vkStream->write((uint64_t*)cgen_var_195, forMarshaling->swapchainCount * 8);
     }
     vkStream->write((const uint32_t*)forMarshaling->pImageIndices, forMarshaling->swapchainCount * sizeof(const uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_186 = (uint64_t)(uintptr_t)forMarshaling->pResults;
-    vkStream->putBe64(cgen_var_186);
+    uint64_t cgen_var_196 = (uint64_t)(uintptr_t)forMarshaling->pResults;
+    vkStream->putBe64(cgen_var_196);
     if (forMarshaling->pResults)
     {
         vkStream->write((VkResult*)forMarshaling->pResults, forMarshaling->swapchainCount * sizeof(VkResult));
@@ -6879,18 +7007,18 @@
     vkStream->read((uint32_t*)&forUnmarshaling->waitSemaphoreCount, sizeof(uint32_t));
     if (forUnmarshaling->waitSemaphoreCount)
     {
-        uint64_t* cgen_var_187;
-        vkStream->alloc((void**)&cgen_var_187, forUnmarshaling->waitSemaphoreCount * 8);
-        vkStream->read((uint64_t*)cgen_var_187, forUnmarshaling->waitSemaphoreCount * 8);
-        vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_187, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
+        uint64_t* cgen_var_197;
+        vkStream->alloc((void**)&cgen_var_197, forUnmarshaling->waitSemaphoreCount * 8);
+        vkStream->read((uint64_t*)cgen_var_197, forUnmarshaling->waitSemaphoreCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkSemaphore(cgen_var_197, (VkSemaphore*)forUnmarshaling->pWaitSemaphores, forUnmarshaling->waitSemaphoreCount);
     }
     vkStream->read((uint32_t*)&forUnmarshaling->swapchainCount, sizeof(uint32_t));
     if (forUnmarshaling->swapchainCount)
     {
-        uint64_t* cgen_var_188;
-        vkStream->alloc((void**)&cgen_var_188, forUnmarshaling->swapchainCount * 8);
-        vkStream->read((uint64_t*)cgen_var_188, forUnmarshaling->swapchainCount * 8);
-        vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_188, (VkSwapchainKHR*)forUnmarshaling->pSwapchains, forUnmarshaling->swapchainCount);
+        uint64_t* cgen_var_198;
+        vkStream->alloc((void**)&cgen_var_198, forUnmarshaling->swapchainCount * 8);
+        vkStream->read((uint64_t*)cgen_var_198, forUnmarshaling->swapchainCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(cgen_var_198, (VkSwapchainKHR*)forUnmarshaling->pSwapchains, forUnmarshaling->swapchainCount);
     }
     vkStream->read((uint32_t*)forUnmarshaling->pImageIndices, forUnmarshaling->swapchainCount * sizeof(const uint32_t));
     // WARNING PTR CHECK
@@ -6918,9 +7046,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_190;
-    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_190, 1);
-    vkStream->write((uint64_t*)&cgen_var_190, 1 * 8);
+    uint64_t cgen_var_200;
+    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_200, 1);
+    vkStream->write((uint64_t*)&cgen_var_200, 1 * 8);
 }
 
 void unmarshal_VkImageSwapchainCreateInfoKHR(
@@ -6936,9 +7064,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_191;
-    vkStream->read((uint64_t*)&cgen_var_191, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_191, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+    uint64_t cgen_var_201;
+    vkStream->read((uint64_t*)&cgen_var_201, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_201, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
 }
 
 void marshal_VkBindImageMemorySwapchainInfoKHR(
@@ -6953,9 +7081,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_192;
-    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_192, 1);
-    vkStream->write((uint64_t*)&cgen_var_192, 1 * 8);
+    uint64_t cgen_var_202;
+    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_202, 1);
+    vkStream->write((uint64_t*)&cgen_var_202, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->imageIndex, sizeof(uint32_t));
 }
 
@@ -6972,9 +7100,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_193;
-    vkStream->read((uint64_t*)&cgen_var_193, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_193, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+    uint64_t cgen_var_203;
+    vkStream->read((uint64_t*)&cgen_var_203, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_203, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->imageIndex, sizeof(uint32_t));
 }
 
@@ -6990,16 +7118,16 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_194;
-    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_194, 1);
-    vkStream->write((uint64_t*)&cgen_var_194, 1 * 8);
+    uint64_t cgen_var_204;
+    vkStream->handleMapping()->mapHandles_VkSwapchainKHR_u64(&forMarshaling->swapchain, &cgen_var_204, 1);
+    vkStream->write((uint64_t*)&cgen_var_204, 1 * 8);
     vkStream->write((uint64_t*)&forMarshaling->timeout, sizeof(uint64_t));
-    uint64_t cgen_var_195;
-    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_195, 1);
-    vkStream->write((uint64_t*)&cgen_var_195, 1 * 8);
-    uint64_t cgen_var_196;
-    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_196, 1);
-    vkStream->write((uint64_t*)&cgen_var_196, 1 * 8);
+    uint64_t cgen_var_205;
+    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_205, 1);
+    vkStream->write((uint64_t*)&cgen_var_205, 1 * 8);
+    uint64_t cgen_var_206;
+    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_206, 1);
+    vkStream->write((uint64_t*)&cgen_var_206, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->deviceMask, sizeof(uint32_t));
 }
 
@@ -7016,16 +7144,16 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_197;
-    vkStream->read((uint64_t*)&cgen_var_197, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_197, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
+    uint64_t cgen_var_207;
+    vkStream->read((uint64_t*)&cgen_var_207, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSwapchainKHR(&cgen_var_207, (VkSwapchainKHR*)&forUnmarshaling->swapchain, 1);
     vkStream->read((uint64_t*)&forUnmarshaling->timeout, sizeof(uint64_t));
-    uint64_t cgen_var_198;
-    vkStream->read((uint64_t*)&cgen_var_198, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_198, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
-    uint64_t cgen_var_199;
-    vkStream->read((uint64_t*)&cgen_var_199, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_199, (VkFence*)&forUnmarshaling->fence, 1);
+    uint64_t cgen_var_208;
+    vkStream->read((uint64_t*)&cgen_var_208, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_208, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+    uint64_t cgen_var_209;
+    vkStream->read((uint64_t*)&cgen_var_209, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_209, (VkFence*)&forUnmarshaling->fence, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->deviceMask, sizeof(uint32_t));
 }
 
@@ -7134,9 +7262,9 @@
     VulkanStreamGuest* vkStream,
     const VkDisplayPropertiesKHR* forMarshaling)
 {
-    uint64_t cgen_var_200;
-    vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->display, &cgen_var_200, 1);
-    vkStream->write((uint64_t*)&cgen_var_200, 1 * 8);
+    uint64_t cgen_var_210;
+    vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->display, &cgen_var_210, 1);
+    vkStream->write((uint64_t*)&cgen_var_210, 1 * 8);
     vkStream->putString(forMarshaling->displayName);
     marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalDimensions));
     marshal_VkExtent2D(vkStream, (VkExtent2D*)(&forMarshaling->physicalResolution));
@@ -7149,9 +7277,9 @@
     VulkanStreamGuest* vkStream,
     VkDisplayPropertiesKHR* forUnmarshaling)
 {
-    uint64_t cgen_var_201;
-    vkStream->read((uint64_t*)&cgen_var_201, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_201, (VkDisplayKHR*)&forUnmarshaling->display, 1);
+    uint64_t cgen_var_211;
+    vkStream->read((uint64_t*)&cgen_var_211, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_211, (VkDisplayKHR*)&forUnmarshaling->display, 1);
     vkStream->loadStringInPlace((char**)&forUnmarshaling->displayName);
     unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->physicalDimensions));
     unmarshal_VkExtent2D(vkStream, (VkExtent2D*)(&forUnmarshaling->physicalResolution));
@@ -7180,9 +7308,9 @@
     VulkanStreamGuest* vkStream,
     const VkDisplayModePropertiesKHR* forMarshaling)
 {
-    uint64_t cgen_var_202;
-    vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_202, 1);
-    vkStream->write((uint64_t*)&cgen_var_202, 1 * 8);
+    uint64_t cgen_var_212;
+    vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_212, 1);
+    vkStream->write((uint64_t*)&cgen_var_212, 1 * 8);
     marshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forMarshaling->parameters));
 }
 
@@ -7190,9 +7318,9 @@
     VulkanStreamGuest* vkStream,
     VkDisplayModePropertiesKHR* forUnmarshaling)
 {
-    uint64_t cgen_var_203;
-    vkStream->read((uint64_t*)&cgen_var_203, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_203, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
+    uint64_t cgen_var_213;
+    vkStream->read((uint64_t*)&cgen_var_213, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_213, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
     unmarshal_VkDisplayModeParametersKHR(vkStream, (VkDisplayModeParametersKHR*)(&forUnmarshaling->parameters));
 }
 
@@ -7263,9 +7391,9 @@
     VulkanStreamGuest* vkStream,
     const VkDisplayPlanePropertiesKHR* forMarshaling)
 {
-    uint64_t cgen_var_204;
-    vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->currentDisplay, &cgen_var_204, 1);
-    vkStream->write((uint64_t*)&cgen_var_204, 1 * 8);
+    uint64_t cgen_var_214;
+    vkStream->handleMapping()->mapHandles_VkDisplayKHR_u64(&forMarshaling->currentDisplay, &cgen_var_214, 1);
+    vkStream->write((uint64_t*)&cgen_var_214, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->currentStackIndex, sizeof(uint32_t));
 }
 
@@ -7273,9 +7401,9 @@
     VulkanStreamGuest* vkStream,
     VkDisplayPlanePropertiesKHR* forUnmarshaling)
 {
-    uint64_t cgen_var_205;
-    vkStream->read((uint64_t*)&cgen_var_205, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_205, (VkDisplayKHR*)&forUnmarshaling->currentDisplay, 1);
+    uint64_t cgen_var_215;
+    vkStream->read((uint64_t*)&cgen_var_215, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDisplayKHR(&cgen_var_215, (VkDisplayKHR*)&forUnmarshaling->currentDisplay, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->currentStackIndex, sizeof(uint32_t));
 }
 
@@ -7292,9 +7420,9 @@
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
     vkStream->write((VkDisplaySurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
-    uint64_t cgen_var_206;
-    vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_206, 1);
-    vkStream->write((uint64_t*)&cgen_var_206, 1 * 8);
+    uint64_t cgen_var_216;
+    vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->displayMode, &cgen_var_216, 1);
+    vkStream->write((uint64_t*)&cgen_var_216, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->planeStackIndex, sizeof(uint32_t));
     vkStream->write((VkSurfaceTransformFlagBitsKHR*)&forMarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
@@ -7317,9 +7445,9 @@
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
     vkStream->read((VkDisplaySurfaceCreateFlagsKHR*)&forUnmarshaling->flags, sizeof(VkDisplaySurfaceCreateFlagsKHR));
-    uint64_t cgen_var_207;
-    vkStream->read((uint64_t*)&cgen_var_207, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_207, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
+    uint64_t cgen_var_217;
+    vkStream->read((uint64_t*)&cgen_var_217, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_217, (VkDisplayModeKHR*)&forUnmarshaling->displayMode, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->planeIndex, sizeof(uint32_t));
     vkStream->read((uint32_t*)&forUnmarshaling->planeStackIndex, sizeof(uint32_t));
     vkStream->read((VkSurfaceTransformFlagBitsKHR*)&forUnmarshaling->transform, sizeof(VkSurfaceTransformFlagBitsKHR));
@@ -7381,8 +7509,8 @@
     }
     vkStream->write((VkXlibSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXlibSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
-    uint64_t cgen_var_208 = (uint64_t)(uintptr_t)forMarshaling->dpy;
-    vkStream->putBe64(cgen_var_208);
+    uint64_t cgen_var_218 = (uint64_t)(uintptr_t)forMarshaling->dpy;
+    vkStream->putBe64(cgen_var_218);
     if (forMarshaling->dpy)
     {
         vkStream->write((Display*)forMarshaling->dpy, sizeof(Display));
@@ -7434,8 +7562,8 @@
     }
     vkStream->write((VkXcbSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkXcbSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
-    uint64_t cgen_var_210 = (uint64_t)(uintptr_t)forMarshaling->connection;
-    vkStream->putBe64(cgen_var_210);
+    uint64_t cgen_var_220 = (uint64_t)(uintptr_t)forMarshaling->connection;
+    vkStream->putBe64(cgen_var_220);
     if (forMarshaling->connection)
     {
         vkStream->write((xcb_connection_t*)forMarshaling->connection, sizeof(xcb_connection_t));
@@ -7487,15 +7615,15 @@
     }
     vkStream->write((VkWaylandSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkWaylandSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
-    uint64_t cgen_var_212 = (uint64_t)(uintptr_t)forMarshaling->display;
-    vkStream->putBe64(cgen_var_212);
+    uint64_t cgen_var_222 = (uint64_t)(uintptr_t)forMarshaling->display;
+    vkStream->putBe64(cgen_var_222);
     if (forMarshaling->display)
     {
         vkStream->write((wl_display*)forMarshaling->display, sizeof(wl_display));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_213 = (uint64_t)(uintptr_t)forMarshaling->surface;
-    vkStream->putBe64(cgen_var_213);
+    uint64_t cgen_var_223 = (uint64_t)(uintptr_t)forMarshaling->surface;
+    vkStream->putBe64(cgen_var_223);
     if (forMarshaling->surface)
     {
         vkStream->write((wl_surface*)forMarshaling->surface, sizeof(wl_surface));
@@ -7556,15 +7684,15 @@
     }
     vkStream->write((VkMirSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkMirSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
-    uint64_t cgen_var_216 = (uint64_t)(uintptr_t)forMarshaling->connection;
-    vkStream->putBe64(cgen_var_216);
+    uint64_t cgen_var_226 = (uint64_t)(uintptr_t)forMarshaling->connection;
+    vkStream->putBe64(cgen_var_226);
     if (forMarshaling->connection)
     {
         vkStream->write((MirConnection*)forMarshaling->connection, sizeof(MirConnection));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_217 = (uint64_t)(uintptr_t)forMarshaling->mirSurface;
-    vkStream->putBe64(cgen_var_217);
+    uint64_t cgen_var_227 = (uint64_t)(uintptr_t)forMarshaling->mirSurface;
+    vkStream->putBe64(cgen_var_227);
     if (forMarshaling->mirSurface)
     {
         vkStream->write((MirSurface*)forMarshaling->mirSurface, sizeof(MirSurface));
@@ -7625,8 +7753,8 @@
     }
     vkStream->write((VkAndroidSurfaceCreateFlagsKHR*)&forMarshaling->flags, sizeof(VkAndroidSurfaceCreateFlagsKHR));
     // WARNING PTR CHECK
-    uint64_t cgen_var_220 = (uint64_t)(uintptr_t)forMarshaling->window;
-    vkStream->putBe64(cgen_var_220);
+    uint64_t cgen_var_230 = (uint64_t)(uintptr_t)forMarshaling->window;
+    vkStream->putBe64(cgen_var_230);
     if (forMarshaling->window)
     {
         vkStream->write((ANativeWindow*)forMarshaling->window, sizeof(ANativeWindow));
@@ -7765,8 +7893,8 @@
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_222 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
-    vkStream->putBe64(cgen_var_222);
+    uint64_t cgen_var_232 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+    vkStream->putBe64(cgen_var_232);
     if (forMarshaling->pAttributes)
     {
         vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
@@ -7846,9 +7974,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_224;
-    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_224, 1);
-    vkStream->write((uint64_t*)&cgen_var_224, 1 * 8);
+    uint64_t cgen_var_234;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_234, 1);
+    vkStream->write((uint64_t*)&cgen_var_234, 1 * 8);
     vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
 }
 
@@ -7865,9 +7993,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_225;
-    vkStream->read((uint64_t*)&cgen_var_225, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_225, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+    uint64_t cgen_var_235;
+    vkStream->read((uint64_t*)&cgen_var_235, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_235, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
     vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
 }
 
@@ -7949,9 +8077,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_226;
-    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_226, 1);
-    vkStream->write((uint64_t*)&cgen_var_226, 1 * 8);
+    uint64_t cgen_var_236;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_236, 1);
+    vkStream->write((uint64_t*)&cgen_var_236, 1 * 8);
     vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
 }
 
@@ -7968,9 +8096,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_227;
-    vkStream->read((uint64_t*)&cgen_var_227, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_227, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+    uint64_t cgen_var_237;
+    vkStream->read((uint64_t*)&cgen_var_237, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_237, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
     vkStream->read((VkExternalMemoryHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
 }
 
@@ -7991,20 +8119,20 @@
     vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
     if (forMarshaling->acquireCount)
     {
-        uint64_t* cgen_var_228;
-        vkStream->alloc((void**)&cgen_var_228, forMarshaling->acquireCount * 8);
-        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_228, forMarshaling->acquireCount);
-        vkStream->write((uint64_t*)cgen_var_228, forMarshaling->acquireCount * 8);
+        uint64_t* cgen_var_238;
+        vkStream->alloc((void**)&cgen_var_238, forMarshaling->acquireCount * 8);
+        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_238, forMarshaling->acquireCount);
+        vkStream->write((uint64_t*)cgen_var_238, forMarshaling->acquireCount * 8);
     }
     vkStream->write((const uint64_t*)forMarshaling->pAcquireKeys, forMarshaling->acquireCount * sizeof(const uint64_t));
     vkStream->write((const uint32_t*)forMarshaling->pAcquireTimeouts, forMarshaling->acquireCount * sizeof(const uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
     if (forMarshaling->releaseCount)
     {
-        uint64_t* cgen_var_229;
-        vkStream->alloc((void**)&cgen_var_229, forMarshaling->releaseCount * 8);
-        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_229, forMarshaling->releaseCount);
-        vkStream->write((uint64_t*)cgen_var_229, forMarshaling->releaseCount * 8);
+        uint64_t* cgen_var_239;
+        vkStream->alloc((void**)&cgen_var_239, forMarshaling->releaseCount * 8);
+        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_239, forMarshaling->releaseCount);
+        vkStream->write((uint64_t*)cgen_var_239, forMarshaling->releaseCount * 8);
     }
     vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
 }
@@ -8025,20 +8153,20 @@
     vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
     if (forUnmarshaling->acquireCount)
     {
-        uint64_t* cgen_var_230;
-        vkStream->alloc((void**)&cgen_var_230, forUnmarshaling->acquireCount * 8);
-        vkStream->read((uint64_t*)cgen_var_230, forUnmarshaling->acquireCount * 8);
-        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_230, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
+        uint64_t* cgen_var_240;
+        vkStream->alloc((void**)&cgen_var_240, forUnmarshaling->acquireCount * 8);
+        vkStream->read((uint64_t*)cgen_var_240, forUnmarshaling->acquireCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_240, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
     }
     vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
     vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeouts, forUnmarshaling->acquireCount * sizeof(const uint32_t));
     vkStream->read((uint32_t*)&forUnmarshaling->releaseCount, sizeof(uint32_t));
     if (forUnmarshaling->releaseCount)
     {
-        uint64_t* cgen_var_231;
-        vkStream->alloc((void**)&cgen_var_231, forUnmarshaling->releaseCount * 8);
-        vkStream->read((uint64_t*)cgen_var_231, forUnmarshaling->releaseCount * 8);
-        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_231, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
+        uint64_t* cgen_var_241;
+        vkStream->alloc((void**)&cgen_var_241, forUnmarshaling->releaseCount * 8);
+        vkStream->read((uint64_t*)cgen_var_241, forUnmarshaling->releaseCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_241, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
     }
     vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
 }
@@ -8061,9 +8189,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_232;
-    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_232, 1);
-    vkStream->write((uint64_t*)&cgen_var_232, 1 * 8);
+    uint64_t cgen_var_242;
+    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_242, 1);
+    vkStream->write((uint64_t*)&cgen_var_242, 1 * 8);
     vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
     vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
     vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
@@ -8083,9 +8211,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_233;
-    vkStream->read((uint64_t*)&cgen_var_233, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_233, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+    uint64_t cgen_var_243;
+    vkStream->read((uint64_t*)&cgen_var_243, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_243, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
     vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreImportFlags));
     vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
     vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
@@ -8105,8 +8233,8 @@
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_234 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
-    vkStream->putBe64(cgen_var_234);
+    uint64_t cgen_var_244 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+    vkStream->putBe64(cgen_var_244);
     if (forMarshaling->pAttributes)
     {
         vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
@@ -8157,16 +8285,16 @@
     }
     vkStream->write((uint32_t*)&forMarshaling->waitSemaphoreValuesCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_236 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
-    vkStream->putBe64(cgen_var_236);
+    uint64_t cgen_var_246 = (uint64_t)(uintptr_t)forMarshaling->pWaitSemaphoreValues;
+    vkStream->putBe64(cgen_var_246);
     if (forMarshaling->pWaitSemaphoreValues)
     {
         vkStream->write((const uint64_t*)forMarshaling->pWaitSemaphoreValues, forMarshaling->waitSemaphoreValuesCount * sizeof(const uint64_t));
     }
     vkStream->write((uint32_t*)&forMarshaling->signalSemaphoreValuesCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_237 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
-    vkStream->putBe64(cgen_var_237);
+    uint64_t cgen_var_247 = (uint64_t)(uintptr_t)forMarshaling->pSignalSemaphoreValues;
+    vkStream->putBe64(cgen_var_247);
     if (forMarshaling->pSignalSemaphoreValues)
     {
         vkStream->write((const uint64_t*)forMarshaling->pSignalSemaphoreValues, forMarshaling->signalSemaphoreValuesCount * sizeof(const uint64_t));
@@ -8224,9 +8352,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_240;
-    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_240, 1);
-    vkStream->write((uint64_t*)&cgen_var_240, 1 * 8);
+    uint64_t cgen_var_250;
+    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_250, 1);
+    vkStream->write((uint64_t*)&cgen_var_250, 1 * 8);
     vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
 }
 
@@ -8243,9 +8371,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_241;
-    vkStream->read((uint64_t*)&cgen_var_241, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_241, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+    uint64_t cgen_var_251;
+    vkStream->read((uint64_t*)&cgen_var_251, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_251, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
     vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
 }
 
@@ -8263,9 +8391,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_242;
-    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_242, 1);
-    vkStream->write((uint64_t*)&cgen_var_242, 1 * 8);
+    uint64_t cgen_var_252;
+    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_252, 1);
+    vkStream->write((uint64_t*)&cgen_var_252, 1 * 8);
     vkStream->write((VkSemaphoreImportFlags*)&forMarshaling->flags, sizeof(VkSemaphoreImportFlags));
     vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
     vkStream->write((int*)&forMarshaling->fd, sizeof(int));
@@ -8284,9 +8412,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_243;
-    vkStream->read((uint64_t*)&cgen_var_243, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_243, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+    uint64_t cgen_var_253;
+    vkStream->read((uint64_t*)&cgen_var_253, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_253, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
     vkStream->read((VkSemaphoreImportFlags*)&forUnmarshaling->flags, sizeof(VkSemaphoreImportFlags));
     vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
     vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
@@ -8304,9 +8432,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_244;
-    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_244, 1);
-    vkStream->write((uint64_t*)&cgen_var_244, 1 * 8);
+    uint64_t cgen_var_254;
+    vkStream->handleMapping()->mapHandles_VkSemaphore_u64(&forMarshaling->semaphore, &cgen_var_254, 1);
+    vkStream->write((uint64_t*)&cgen_var_254, 1 * 8);
     vkStream->write((VkExternalSemaphoreHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
 }
 
@@ -8323,9 +8451,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_245;
-    vkStream->read((uint64_t*)&cgen_var_245, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_245, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
+    uint64_t cgen_var_255;
+    vkStream->read((uint64_t*)&cgen_var_255, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSemaphore(&cgen_var_255, (VkSemaphore*)&forUnmarshaling->semaphore, 1);
     vkStream->read((VkExternalSemaphoreHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalSemaphoreHandleTypeFlagBits));
 }
 
@@ -8390,8 +8518,8 @@
 {
     vkStream->write((uint32_t*)&forMarshaling->rectangleCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_246 = (uint64_t)(uintptr_t)forMarshaling->pRectangles;
-    vkStream->putBe64(cgen_var_246);
+    uint64_t cgen_var_256 = (uint64_t)(uintptr_t)forMarshaling->pRectangles;
+    vkStream->putBe64(cgen_var_256);
     if (forMarshaling->pRectangles)
     {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->rectangleCount; ++i)
@@ -8436,8 +8564,8 @@
     }
     vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_248 = (uint64_t)(uintptr_t)forMarshaling->pRegions;
-    vkStream->putBe64(cgen_var_248);
+    uint64_t cgen_var_258 = (uint64_t)(uintptr_t)forMarshaling->pRegions;
+    vkStream->putBe64(cgen_var_258);
     if (forMarshaling->pRegions)
     {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
@@ -8589,8 +8717,8 @@
         marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pColorAttachments + i));
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_250 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
-    vkStream->putBe64(cgen_var_250);
+    uint64_t cgen_var_260 = (uint64_t)(uintptr_t)forMarshaling->pResolveAttachments;
+    vkStream->putBe64(cgen_var_260);
     if (forMarshaling->pResolveAttachments)
     {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->colorAttachmentCount; ++i)
@@ -8599,8 +8727,8 @@
         }
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_251 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
-    vkStream->putBe64(cgen_var_251);
+    uint64_t cgen_var_261 = (uint64_t)(uintptr_t)forMarshaling->pDepthStencilAttachment;
+    vkStream->putBe64(cgen_var_261);
     if (forMarshaling->pDepthStencilAttachment)
     {
         marshal_VkAttachmentReference2KHR(vkStream, (const VkAttachmentReference2KHR*)(forMarshaling->pDepthStencilAttachment));
@@ -8885,9 +9013,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_254;
-    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_254, 1);
-    vkStream->write((uint64_t*)&cgen_var_254, 1 * 8);
+    uint64_t cgen_var_264;
+    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_264, 1);
+    vkStream->write((uint64_t*)&cgen_var_264, 1 * 8);
     vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
     vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
     vkStream->write((HANDLE*)&forMarshaling->handle, sizeof(HANDLE));
@@ -8907,9 +9035,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_255;
-    vkStream->read((uint64_t*)&cgen_var_255, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_255, (VkFence*)&forUnmarshaling->fence, 1);
+    uint64_t cgen_var_265;
+    vkStream->read((uint64_t*)&cgen_var_265, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_265, (VkFence*)&forUnmarshaling->fence, 1);
     vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
     vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
     vkStream->read((HANDLE*)&forUnmarshaling->handle, sizeof(HANDLE));
@@ -8929,8 +9057,8 @@
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_256 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
-    vkStream->putBe64(cgen_var_256);
+    uint64_t cgen_var_266 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+    vkStream->putBe64(cgen_var_266);
     if (forMarshaling->pAttributes)
     {
         vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
@@ -8979,9 +9107,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_258;
-    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_258, 1);
-    vkStream->write((uint64_t*)&cgen_var_258, 1 * 8);
+    uint64_t cgen_var_268;
+    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_268, 1);
+    vkStream->write((uint64_t*)&cgen_var_268, 1 * 8);
     vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
 }
 
@@ -8998,9 +9126,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_259;
-    vkStream->read((uint64_t*)&cgen_var_259, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_259, (VkFence*)&forUnmarshaling->fence, 1);
+    uint64_t cgen_var_269;
+    vkStream->read((uint64_t*)&cgen_var_269, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_269, (VkFence*)&forUnmarshaling->fence, 1);
     vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
 }
 
@@ -9018,9 +9146,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_260;
-    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_260, 1);
-    vkStream->write((uint64_t*)&cgen_var_260, 1 * 8);
+    uint64_t cgen_var_270;
+    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_270, 1);
+    vkStream->write((uint64_t*)&cgen_var_270, 1 * 8);
     vkStream->write((VkFenceImportFlags*)&forMarshaling->flags, sizeof(VkFenceImportFlags));
     vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
     vkStream->write((int*)&forMarshaling->fd, sizeof(int));
@@ -9039,9 +9167,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_261;
-    vkStream->read((uint64_t*)&cgen_var_261, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_261, (VkFence*)&forUnmarshaling->fence, 1);
+    uint64_t cgen_var_271;
+    vkStream->read((uint64_t*)&cgen_var_271, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_271, (VkFence*)&forUnmarshaling->fence, 1);
     vkStream->read((VkFenceImportFlags*)&forUnmarshaling->flags, sizeof(VkFenceImportFlags));
     vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
     vkStream->read((int*)&forUnmarshaling->fd, sizeof(int));
@@ -9059,9 +9187,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_262;
-    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_262, 1);
-    vkStream->write((uint64_t*)&cgen_var_262, 1 * 8);
+    uint64_t cgen_var_272;
+    vkStream->handleMapping()->mapHandles_VkFence_u64(&forMarshaling->fence, &cgen_var_272, 1);
+    vkStream->write((uint64_t*)&cgen_var_272, 1 * 8);
     vkStream->write((VkExternalFenceHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
 }
 
@@ -9078,9 +9206,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_263;
-    vkStream->read((uint64_t*)&cgen_var_263, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_263, (VkFence*)&forUnmarshaling->fence, 1);
+    uint64_t cgen_var_273;
+    vkStream->read((uint64_t*)&cgen_var_273, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkFence(&cgen_var_273, (VkFence*)&forUnmarshaling->fence, 1);
     vkStream->read((VkExternalFenceHandleTypeFlagBits*)&forUnmarshaling->handleType, sizeof(VkExternalFenceHandleTypeFlagBits));
 }
 
@@ -9100,9 +9228,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_264;
-    vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_264, 1);
-    vkStream->write((uint64_t*)&cgen_var_264, 1 * 8);
+    uint64_t cgen_var_274;
+    vkStream->handleMapping()->mapHandles_VkSurfaceKHR_u64(&forMarshaling->surface, &cgen_var_274, 1);
+    vkStream->write((uint64_t*)&cgen_var_274, 1 * 8);
 }
 
 void unmarshal_VkPhysicalDeviceSurfaceInfo2KHR(
@@ -9118,9 +9246,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_265;
-    vkStream->read((uint64_t*)&cgen_var_265, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_265, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
+    uint64_t cgen_var_275;
+    vkStream->read((uint64_t*)&cgen_var_275, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkSurfaceKHR(&cgen_var_275, (VkSurfaceKHR*)&forUnmarshaling->surface, 1);
 }
 
 void marshal_VkSurfaceCapabilities2KHR(
@@ -9294,9 +9422,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_266;
-    vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->mode, &cgen_var_266, 1);
-    vkStream->write((uint64_t*)&cgen_var_266, 1 * 8);
+    uint64_t cgen_var_276;
+    vkStream->handleMapping()->mapHandles_VkDisplayModeKHR_u64(&forMarshaling->mode, &cgen_var_276, 1);
+    vkStream->write((uint64_t*)&cgen_var_276, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->planeIndex, sizeof(uint32_t));
 }
 
@@ -9313,9 +9441,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_267;
-    vkStream->read((uint64_t*)&cgen_var_267, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_267, (VkDisplayModeKHR*)&forUnmarshaling->mode, 1);
+    uint64_t cgen_var_277;
+    vkStream->read((uint64_t*)&cgen_var_277, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDisplayModeKHR(&cgen_var_277, (VkDisplayModeKHR*)&forUnmarshaling->mode, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->planeIndex, sizeof(uint32_t));
 }
 
@@ -9453,8 +9581,8 @@
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_268 = (uint64_t)(uintptr_t)forMarshaling->handle;
-    vkStream->putBe64(cgen_var_268);
+    uint64_t cgen_var_278 = (uint64_t)(uintptr_t)forMarshaling->handle;
+    vkStream->putBe64(cgen_var_278);
     if (forMarshaling->handle)
     {
         vkStream->write((const uint32_t*)forMarshaling->handle, sizeof(const uint32_t));
@@ -9512,11 +9640,11 @@
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
     vkStream->write((VkDebugReportFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugReportFlagsEXT));
-    uint64_t cgen_var_270 = (uint64_t)forMarshaling->pfnCallback;
-    vkStream->putBe64(cgen_var_270);
+    uint64_t cgen_var_280 = (uint64_t)forMarshaling->pfnCallback;
+    vkStream->putBe64(cgen_var_280);
     // WARNING PTR CHECK
-    uint64_t cgen_var_271 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
-    vkStream->putBe64(cgen_var_271);
+    uint64_t cgen_var_281 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+    vkStream->putBe64(cgen_var_281);
     if (forMarshaling->pUserData)
     {
         vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
@@ -9646,8 +9774,8 @@
     vkStream->write((VkDebugReportObjectTypeEXT*)&forMarshaling->objectType, sizeof(VkDebugReportObjectTypeEXT));
     vkStream->write((uint64_t*)&forMarshaling->object, sizeof(uint64_t));
     vkStream->write((uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
-    uint64_t cgen_var_274 = (uint64_t)forMarshaling->tagSize;
-    vkStream->putBe64(cgen_var_274);
+    uint64_t cgen_var_284 = (uint64_t)forMarshaling->tagSize;
+    vkStream->putBe64(cgen_var_284);
     vkStream->write((const void*)forMarshaling->pTag, forMarshaling->tagSize * sizeof(const uint8_t));
 }
 
@@ -9782,12 +9910,12 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_276;
-    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_276, 1);
-    vkStream->write((uint64_t*)&cgen_var_276, 1 * 8);
-    uint64_t cgen_var_277;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_277, 1);
-    vkStream->write((uint64_t*)&cgen_var_277, 1 * 8);
+    uint64_t cgen_var_286;
+    vkStream->handleMapping()->mapHandles_VkImage_u64(&forMarshaling->image, &cgen_var_286, 1);
+    vkStream->write((uint64_t*)&cgen_var_286, 1 * 8);
+    uint64_t cgen_var_287;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_287, 1);
+    vkStream->write((uint64_t*)&cgen_var_287, 1 * 8);
 }
 
 void unmarshal_VkDedicatedAllocationMemoryAllocateInfoNV(
@@ -9803,12 +9931,12 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_278;
-    vkStream->read((uint64_t*)&cgen_var_278, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_278, (VkImage*)&forUnmarshaling->image, 1);
-    uint64_t cgen_var_279;
-    vkStream->read((uint64_t*)&cgen_var_279, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_279, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    uint64_t cgen_var_288;
+    vkStream->read((uint64_t*)&cgen_var_288, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkImage(&cgen_var_288, (VkImage*)&forUnmarshaling->image, 1);
+    uint64_t cgen_var_289;
+    vkStream->read((uint64_t*)&cgen_var_289, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_289, (VkBuffer*)&forUnmarshaling->buffer, 1);
 }
 
 #endif
@@ -9861,10 +9989,10 @@
     vkStream->write((uint32_t*)&forMarshaling->numUsedVgprs, sizeof(uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->numUsedSgprs, sizeof(uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->ldsSizePerLocalWorkGroup, sizeof(uint32_t));
-    uint64_t cgen_var_280 = (uint64_t)forMarshaling->ldsUsageSizeInBytes;
-    vkStream->putBe64(cgen_var_280);
-    uint64_t cgen_var_281 = (uint64_t)forMarshaling->scratchMemUsageInBytes;
-    vkStream->putBe64(cgen_var_281);
+    uint64_t cgen_var_290 = (uint64_t)forMarshaling->ldsUsageSizeInBytes;
+    vkStream->putBe64(cgen_var_290);
+    uint64_t cgen_var_291 = (uint64_t)forMarshaling->scratchMemUsageInBytes;
+    vkStream->putBe64(cgen_var_291);
 }
 
 void unmarshal_VkShaderResourceUsageAMD(
@@ -10042,8 +10170,8 @@
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
     // WARNING PTR CHECK
-    uint64_t cgen_var_284 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
-    vkStream->putBe64(cgen_var_284);
+    uint64_t cgen_var_294 = (uint64_t)(uintptr_t)forMarshaling->pAttributes;
+    vkStream->putBe64(cgen_var_294);
     if (forMarshaling->pAttributes)
     {
         vkStream->write((const SECURITY_ATTRIBUTES*)forMarshaling->pAttributes, sizeof(const SECURITY_ATTRIBUTES));
@@ -10095,20 +10223,20 @@
     vkStream->write((uint32_t*)&forMarshaling->acquireCount, sizeof(uint32_t));
     if (forMarshaling->acquireCount)
     {
-        uint64_t* cgen_var_286;
-        vkStream->alloc((void**)&cgen_var_286, forMarshaling->acquireCount * 8);
-        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_286, forMarshaling->acquireCount);
-        vkStream->write((uint64_t*)cgen_var_286, forMarshaling->acquireCount * 8);
+        uint64_t* cgen_var_296;
+        vkStream->alloc((void**)&cgen_var_296, forMarshaling->acquireCount * 8);
+        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pAcquireSyncs, cgen_var_296, forMarshaling->acquireCount);
+        vkStream->write((uint64_t*)cgen_var_296, forMarshaling->acquireCount * 8);
     }
     vkStream->write((const uint64_t*)forMarshaling->pAcquireKeys, forMarshaling->acquireCount * sizeof(const uint64_t));
     vkStream->write((const uint32_t*)forMarshaling->pAcquireTimeoutMilliseconds, forMarshaling->acquireCount * sizeof(const uint32_t));
     vkStream->write((uint32_t*)&forMarshaling->releaseCount, sizeof(uint32_t));
     if (forMarshaling->releaseCount)
     {
-        uint64_t* cgen_var_287;
-        vkStream->alloc((void**)&cgen_var_287, forMarshaling->releaseCount * 8);
-        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_287, forMarshaling->releaseCount);
-        vkStream->write((uint64_t*)cgen_var_287, forMarshaling->releaseCount * 8);
+        uint64_t* cgen_var_297;
+        vkStream->alloc((void**)&cgen_var_297, forMarshaling->releaseCount * 8);
+        vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(forMarshaling->pReleaseSyncs, cgen_var_297, forMarshaling->releaseCount);
+        vkStream->write((uint64_t*)cgen_var_297, forMarshaling->releaseCount * 8);
     }
     vkStream->write((const uint64_t*)forMarshaling->pReleaseKeys, forMarshaling->releaseCount * sizeof(const uint64_t));
 }
@@ -10129,20 +10257,20 @@
     vkStream->read((uint32_t*)&forUnmarshaling->acquireCount, sizeof(uint32_t));
     if (forUnmarshaling->acquireCount)
     {
-        uint64_t* cgen_var_288;
-        vkStream->alloc((void**)&cgen_var_288, forUnmarshaling->acquireCount * 8);
-        vkStream->read((uint64_t*)cgen_var_288, forUnmarshaling->acquireCount * 8);
-        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_288, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
+        uint64_t* cgen_var_298;
+        vkStream->alloc((void**)&cgen_var_298, forUnmarshaling->acquireCount * 8);
+        vkStream->read((uint64_t*)cgen_var_298, forUnmarshaling->acquireCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_298, (VkDeviceMemory*)forUnmarshaling->pAcquireSyncs, forUnmarshaling->acquireCount);
     }
     vkStream->read((uint64_t*)forUnmarshaling->pAcquireKeys, forUnmarshaling->acquireCount * sizeof(const uint64_t));
     vkStream->read((uint32_t*)forUnmarshaling->pAcquireTimeoutMilliseconds, forUnmarshaling->acquireCount * sizeof(const uint32_t));
     vkStream->read((uint32_t*)&forUnmarshaling->releaseCount, sizeof(uint32_t));
     if (forUnmarshaling->releaseCount)
     {
-        uint64_t* cgen_var_289;
-        vkStream->alloc((void**)&cgen_var_289, forUnmarshaling->releaseCount * 8);
-        vkStream->read((uint64_t*)cgen_var_289, forUnmarshaling->releaseCount * 8);
-        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_289, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
+        uint64_t* cgen_var_299;
+        vkStream->alloc((void**)&cgen_var_299, forUnmarshaling->releaseCount * 8);
+        vkStream->read((uint64_t*)cgen_var_299, forUnmarshaling->releaseCount * 8);
+        vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(cgen_var_299, (VkDeviceMemory*)forUnmarshaling->pReleaseSyncs, forUnmarshaling->releaseCount);
     }
     vkStream->read((uint64_t*)forUnmarshaling->pReleaseKeys, forUnmarshaling->releaseCount * sizeof(const uint64_t));
 }
@@ -10198,8 +10326,8 @@
     }
     vkStream->write((VkViSurfaceCreateFlagsNN*)&forMarshaling->flags, sizeof(VkViSurfaceCreateFlagsNN));
     // WARNING PTR CHECK
-    uint64_t cgen_var_290 = (uint64_t)(uintptr_t)forMarshaling->window;
-    vkStream->putBe64(cgen_var_290);
+    uint64_t cgen_var_300 = (uint64_t)(uintptr_t)forMarshaling->window;
+    vkStream->putBe64(cgen_var_300);
     if (forMarshaling->window)
     {
         vkStream->write((void*)forMarshaling->window, sizeof(uint8_t));
@@ -10251,9 +10379,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_292;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_292, 1);
-    vkStream->write((uint64_t*)&cgen_var_292, 1 * 8);
+    uint64_t cgen_var_302;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_302, 1);
+    vkStream->write((uint64_t*)&cgen_var_302, 1 * 8);
     vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
     vkStream->write((VkConditionalRenderingFlagsEXT*)&forMarshaling->flags, sizeof(VkConditionalRenderingFlagsEXT));
 }
@@ -10271,9 +10399,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_293;
-    vkStream->read((uint64_t*)&cgen_var_293, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_293, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    uint64_t cgen_var_303;
+    vkStream->read((uint64_t*)&cgen_var_303, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_303, (VkBuffer*)&forUnmarshaling->buffer, 1);
     vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
     vkStream->read((VkConditionalRenderingFlagsEXT*)&forUnmarshaling->flags, sizeof(VkConditionalRenderingFlagsEXT));
 }
@@ -10419,9 +10547,9 @@
     const VkIndirectCommandsTokenNVX* forMarshaling)
 {
     vkStream->write((VkIndirectCommandsTokenTypeNVX*)&forMarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
-    uint64_t cgen_var_294;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_294, 1);
-    vkStream->write((uint64_t*)&cgen_var_294, 1 * 8);
+    uint64_t cgen_var_304;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_304, 1);
+    vkStream->write((uint64_t*)&cgen_var_304, 1 * 8);
     vkStream->write((VkDeviceSize*)&forMarshaling->offset, sizeof(VkDeviceSize));
 }
 
@@ -10430,9 +10558,9 @@
     VkIndirectCommandsTokenNVX* forUnmarshaling)
 {
     vkStream->read((VkIndirectCommandsTokenTypeNVX*)&forUnmarshaling->tokenType, sizeof(VkIndirectCommandsTokenTypeNVX));
-    uint64_t cgen_var_295;
-    vkStream->read((uint64_t*)&cgen_var_295, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_295, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    uint64_t cgen_var_305;
+    vkStream->read((uint64_t*)&cgen_var_305, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_305, (VkBuffer*)&forUnmarshaling->buffer, 1);
     vkStream->read((VkDeviceSize*)&forUnmarshaling->offset, sizeof(VkDeviceSize));
 }
 
@@ -10511,28 +10639,28 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_296;
-    vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_296, 1);
-    vkStream->write((uint64_t*)&cgen_var_296, 1 * 8);
-    uint64_t cgen_var_297;
-    vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_297, 1);
-    vkStream->write((uint64_t*)&cgen_var_297, 1 * 8);
+    uint64_t cgen_var_306;
+    vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_306, 1);
+    vkStream->write((uint64_t*)&cgen_var_306, 1 * 8);
+    uint64_t cgen_var_307;
+    vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_307, 1);
+    vkStream->write((uint64_t*)&cgen_var_307, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->indirectCommandsTokenCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forMarshaling->indirectCommandsTokenCount; ++i)
     {
         marshal_VkIndirectCommandsTokenNVX(vkStream, (const VkIndirectCommandsTokenNVX*)(forMarshaling->pIndirectCommandsTokens + i));
     }
     vkStream->write((uint32_t*)&forMarshaling->maxSequencesCount, sizeof(uint32_t));
-    uint64_t cgen_var_298;
-    vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&forMarshaling->targetCommandBuffer, &cgen_var_298, 1);
-    vkStream->write((uint64_t*)&cgen_var_298, 1 * 8);
-    uint64_t cgen_var_299;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesCountBuffer, &cgen_var_299, 1);
-    vkStream->write((uint64_t*)&cgen_var_299, 1 * 8);
+    uint64_t cgen_var_308;
+    vkStream->handleMapping()->mapHandles_VkCommandBuffer_u64(&forMarshaling->targetCommandBuffer, &cgen_var_308, 1);
+    vkStream->write((uint64_t*)&cgen_var_308, 1 * 8);
+    uint64_t cgen_var_309;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesCountBuffer, &cgen_var_309, 1);
+    vkStream->write((uint64_t*)&cgen_var_309, 1 * 8);
     vkStream->write((VkDeviceSize*)&forMarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
-    uint64_t cgen_var_300;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesIndexBuffer, &cgen_var_300, 1);
-    vkStream->write((uint64_t*)&cgen_var_300, 1 * 8);
+    uint64_t cgen_var_310;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->sequencesIndexBuffer, &cgen_var_310, 1);
+    vkStream->write((uint64_t*)&cgen_var_310, 1 * 8);
     vkStream->write((VkDeviceSize*)&forMarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
 }
 
@@ -10549,28 +10677,28 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_301;
-    vkStream->read((uint64_t*)&cgen_var_301, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_301, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
-    uint64_t cgen_var_302;
-    vkStream->read((uint64_t*)&cgen_var_302, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_302, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
+    uint64_t cgen_var_311;
+    vkStream->read((uint64_t*)&cgen_var_311, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_311, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
+    uint64_t cgen_var_312;
+    vkStream->read((uint64_t*)&cgen_var_312, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_312, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->indirectCommandsTokenCount, sizeof(uint32_t));
     for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->indirectCommandsTokenCount; ++i)
     {
         unmarshal_VkIndirectCommandsTokenNVX(vkStream, (VkIndirectCommandsTokenNVX*)(forUnmarshaling->pIndirectCommandsTokens + i));
     }
     vkStream->read((uint32_t*)&forUnmarshaling->maxSequencesCount, sizeof(uint32_t));
-    uint64_t cgen_var_303;
-    vkStream->read((uint64_t*)&cgen_var_303, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(&cgen_var_303, (VkCommandBuffer*)&forUnmarshaling->targetCommandBuffer, 1);
-    uint64_t cgen_var_304;
-    vkStream->read((uint64_t*)&cgen_var_304, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_304, (VkBuffer*)&forUnmarshaling->sequencesCountBuffer, 1);
+    uint64_t cgen_var_313;
+    vkStream->read((uint64_t*)&cgen_var_313, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkCommandBuffer(&cgen_var_313, (VkCommandBuffer*)&forUnmarshaling->targetCommandBuffer, 1);
+    uint64_t cgen_var_314;
+    vkStream->read((uint64_t*)&cgen_var_314, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_314, (VkBuffer*)&forUnmarshaling->sequencesCountBuffer, 1);
     vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesCountOffset, sizeof(VkDeviceSize));
-    uint64_t cgen_var_305;
-    vkStream->read((uint64_t*)&cgen_var_305, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_305, (VkBuffer*)&forUnmarshaling->sequencesIndexBuffer, 1);
+    uint64_t cgen_var_315;
+    vkStream->read((uint64_t*)&cgen_var_315, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_315, (VkBuffer*)&forUnmarshaling->sequencesIndexBuffer, 1);
     vkStream->read((VkDeviceSize*)&forUnmarshaling->sequencesIndexOffset, sizeof(VkDeviceSize));
 }
 
@@ -10586,12 +10714,12 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_306;
-    vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_306, 1);
-    vkStream->write((uint64_t*)&cgen_var_306, 1 * 8);
-    uint64_t cgen_var_307;
-    vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_307, 1);
-    vkStream->write((uint64_t*)&cgen_var_307, 1 * 8);
+    uint64_t cgen_var_316;
+    vkStream->handleMapping()->mapHandles_VkObjectTableNVX_u64(&forMarshaling->objectTable, &cgen_var_316, 1);
+    vkStream->write((uint64_t*)&cgen_var_316, 1 * 8);
+    uint64_t cgen_var_317;
+    vkStream->handleMapping()->mapHandles_VkIndirectCommandsLayoutNVX_u64(&forMarshaling->indirectCommandsLayout, &cgen_var_317, 1);
+    vkStream->write((uint64_t*)&cgen_var_317, 1 * 8);
     vkStream->write((uint32_t*)&forMarshaling->maxSequencesCount, sizeof(uint32_t));
 }
 
@@ -10608,12 +10736,12 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_308;
-    vkStream->read((uint64_t*)&cgen_var_308, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_308, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
-    uint64_t cgen_var_309;
-    vkStream->read((uint64_t*)&cgen_var_309, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_309, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
+    uint64_t cgen_var_318;
+    vkStream->read((uint64_t*)&cgen_var_318, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkObjectTableNVX(&cgen_var_318, (VkObjectTableNVX*)&forUnmarshaling->objectTable, 1);
+    uint64_t cgen_var_319;
+    vkStream->read((uint64_t*)&cgen_var_319, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkIndirectCommandsLayoutNVX(&cgen_var_319, (VkIndirectCommandsLayoutNVX*)&forUnmarshaling->indirectCommandsLayout, 1);
     vkStream->read((uint32_t*)&forUnmarshaling->maxSequencesCount, sizeof(uint32_t));
 }
 
@@ -10686,9 +10814,9 @@
 {
     vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
     vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
-    uint64_t cgen_var_310;
-    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_310, 1);
-    vkStream->write((uint64_t*)&cgen_var_310, 1 * 8);
+    uint64_t cgen_var_320;
+    vkStream->handleMapping()->mapHandles_VkPipeline_u64(&forMarshaling->pipeline, &cgen_var_320, 1);
+    vkStream->write((uint64_t*)&cgen_var_320, 1 * 8);
 }
 
 void unmarshal_VkObjectTablePipelineEntryNVX(
@@ -10697,9 +10825,9 @@
 {
     vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
     vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
-    uint64_t cgen_var_311;
-    vkStream->read((uint64_t*)&cgen_var_311, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_311, (VkPipeline*)&forUnmarshaling->pipeline, 1);
+    uint64_t cgen_var_321;
+    vkStream->read((uint64_t*)&cgen_var_321, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipeline(&cgen_var_321, (VkPipeline*)&forUnmarshaling->pipeline, 1);
 }
 
 void marshal_VkObjectTableDescriptorSetEntryNVX(
@@ -10708,12 +10836,12 @@
 {
     vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
     vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
-    uint64_t cgen_var_312;
-    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_312, 1);
-    vkStream->write((uint64_t*)&cgen_var_312, 1 * 8);
-    uint64_t cgen_var_313;
-    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->descriptorSet, &cgen_var_313, 1);
-    vkStream->write((uint64_t*)&cgen_var_313, 1 * 8);
+    uint64_t cgen_var_322;
+    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_322, 1);
+    vkStream->write((uint64_t*)&cgen_var_322, 1 * 8);
+    uint64_t cgen_var_323;
+    vkStream->handleMapping()->mapHandles_VkDescriptorSet_u64(&forMarshaling->descriptorSet, &cgen_var_323, 1);
+    vkStream->write((uint64_t*)&cgen_var_323, 1 * 8);
 }
 
 void unmarshal_VkObjectTableDescriptorSetEntryNVX(
@@ -10722,12 +10850,12 @@
 {
     vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
     vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
-    uint64_t cgen_var_314;
-    vkStream->read((uint64_t*)&cgen_var_314, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_314, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
-    uint64_t cgen_var_315;
-    vkStream->read((uint64_t*)&cgen_var_315, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_315, (VkDescriptorSet*)&forUnmarshaling->descriptorSet, 1);
+    uint64_t cgen_var_324;
+    vkStream->read((uint64_t*)&cgen_var_324, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_324, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+    uint64_t cgen_var_325;
+    vkStream->read((uint64_t*)&cgen_var_325, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDescriptorSet(&cgen_var_325, (VkDescriptorSet*)&forUnmarshaling->descriptorSet, 1);
 }
 
 void marshal_VkObjectTableVertexBufferEntryNVX(
@@ -10736,9 +10864,9 @@
 {
     vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
     vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
-    uint64_t cgen_var_316;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_316, 1);
-    vkStream->write((uint64_t*)&cgen_var_316, 1 * 8);
+    uint64_t cgen_var_326;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_326, 1);
+    vkStream->write((uint64_t*)&cgen_var_326, 1 * 8);
 }
 
 void unmarshal_VkObjectTableVertexBufferEntryNVX(
@@ -10747,9 +10875,9 @@
 {
     vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
     vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
-    uint64_t cgen_var_317;
-    vkStream->read((uint64_t*)&cgen_var_317, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_317, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    uint64_t cgen_var_327;
+    vkStream->read((uint64_t*)&cgen_var_327, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_327, (VkBuffer*)&forUnmarshaling->buffer, 1);
 }
 
 void marshal_VkObjectTableIndexBufferEntryNVX(
@@ -10758,9 +10886,9 @@
 {
     vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
     vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
-    uint64_t cgen_var_318;
-    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_318, 1);
-    vkStream->write((uint64_t*)&cgen_var_318, 1 * 8);
+    uint64_t cgen_var_328;
+    vkStream->handleMapping()->mapHandles_VkBuffer_u64(&forMarshaling->buffer, &cgen_var_328, 1);
+    vkStream->write((uint64_t*)&cgen_var_328, 1 * 8);
     vkStream->write((VkIndexType*)&forMarshaling->indexType, sizeof(VkIndexType));
 }
 
@@ -10770,9 +10898,9 @@
 {
     vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
     vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
-    uint64_t cgen_var_319;
-    vkStream->read((uint64_t*)&cgen_var_319, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_319, (VkBuffer*)&forUnmarshaling->buffer, 1);
+    uint64_t cgen_var_329;
+    vkStream->read((uint64_t*)&cgen_var_329, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkBuffer(&cgen_var_329, (VkBuffer*)&forUnmarshaling->buffer, 1);
     vkStream->read((VkIndexType*)&forUnmarshaling->indexType, sizeof(VkIndexType));
 }
 
@@ -10782,9 +10910,9 @@
 {
     vkStream->write((VkObjectEntryTypeNVX*)&forMarshaling->type, sizeof(VkObjectEntryTypeNVX));
     vkStream->write((VkObjectEntryUsageFlagsNVX*)&forMarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
-    uint64_t cgen_var_320;
-    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_320, 1);
-    vkStream->write((uint64_t*)&cgen_var_320, 1 * 8);
+    uint64_t cgen_var_330;
+    vkStream->handleMapping()->mapHandles_VkPipelineLayout_u64(&forMarshaling->pipelineLayout, &cgen_var_330, 1);
+    vkStream->write((uint64_t*)&cgen_var_330, 1 * 8);
     vkStream->write((VkShaderStageFlags*)&forMarshaling->stageFlags, sizeof(VkShaderStageFlags));
 }
 
@@ -10794,9 +10922,9 @@
 {
     vkStream->read((VkObjectEntryTypeNVX*)&forUnmarshaling->type, sizeof(VkObjectEntryTypeNVX));
     vkStream->read((VkObjectEntryUsageFlagsNVX*)&forUnmarshaling->flags, sizeof(VkObjectEntryUsageFlagsNVX));
-    uint64_t cgen_var_321;
-    vkStream->read((uint64_t*)&cgen_var_321, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_321, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
+    uint64_t cgen_var_331;
+    vkStream->read((uint64_t*)&cgen_var_331, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkPipelineLayout(&cgen_var_331, (VkPipelineLayout*)&forUnmarshaling->pipelineLayout, 1);
     vkStream->read((VkShaderStageFlags*)&forUnmarshaling->stageFlags, sizeof(VkShaderStageFlags));
 }
 
@@ -10833,8 +10961,8 @@
     vkStream->write((VkBool32*)&forMarshaling->viewportWScalingEnable, sizeof(VkBool32));
     vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_322 = (uint64_t)(uintptr_t)forMarshaling->pViewportWScalings;
-    vkStream->putBe64(cgen_var_322);
+    uint64_t cgen_var_332 = (uint64_t)(uintptr_t)forMarshaling->pViewportWScalings;
+    vkStream->putBe64(cgen_var_332);
     if (forMarshaling->pViewportWScalings)
     {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
@@ -11126,8 +11254,8 @@
     }
     vkStream->write((uint32_t*)&forMarshaling->swapchainCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_324 = (uint64_t)(uintptr_t)forMarshaling->pTimes;
-    vkStream->putBe64(cgen_var_324);
+    uint64_t cgen_var_334 = (uint64_t)(uintptr_t)forMarshaling->pTimes;
+    vkStream->putBe64(cgen_var_334);
     if (forMarshaling->pTimes)
     {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->swapchainCount; ++i)
@@ -11243,8 +11371,8 @@
     vkStream->write((VkPipelineViewportSwizzleStateCreateFlagsNV*)&forMarshaling->flags, sizeof(VkPipelineViewportSwizzleStateCreateFlagsNV));
     vkStream->write((uint32_t*)&forMarshaling->viewportCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_326 = (uint64_t)(uintptr_t)forMarshaling->pViewportSwizzles;
-    vkStream->putBe64(cgen_var_326);
+    uint64_t cgen_var_336 = (uint64_t)(uintptr_t)forMarshaling->pViewportSwizzles;
+    vkStream->putBe64(cgen_var_336);
     if (forMarshaling->pViewportSwizzles)
     {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->viewportCount; ++i)
@@ -11334,8 +11462,8 @@
     vkStream->write((VkDiscardRectangleModeEXT*)&forMarshaling->discardRectangleMode, sizeof(VkDiscardRectangleModeEXT));
     vkStream->write((uint32_t*)&forMarshaling->discardRectangleCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_328 = (uint64_t)(uintptr_t)forMarshaling->pDiscardRectangles;
-    vkStream->putBe64(cgen_var_328);
+    uint64_t cgen_var_338 = (uint64_t)(uintptr_t)forMarshaling->pDiscardRectangles;
+    vkStream->putBe64(cgen_var_338);
     if (forMarshaling->pDiscardRectangles)
     {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->discardRectangleCount; ++i)
@@ -11542,8 +11670,8 @@
     }
     vkStream->write((VkIOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkIOSSurfaceCreateFlagsMVK));
     // WARNING PTR CHECK
-    uint64_t cgen_var_330 = (uint64_t)(uintptr_t)forMarshaling->pView;
-    vkStream->putBe64(cgen_var_330);
+    uint64_t cgen_var_340 = (uint64_t)(uintptr_t)forMarshaling->pView;
+    vkStream->putBe64(cgen_var_340);
     if (forMarshaling->pView)
     {
         vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
@@ -11593,8 +11721,8 @@
     }
     vkStream->write((VkMacOSSurfaceCreateFlagsMVK*)&forMarshaling->flags, sizeof(VkMacOSSurfaceCreateFlagsMVK));
     // WARNING PTR CHECK
-    uint64_t cgen_var_332 = (uint64_t)(uintptr_t)forMarshaling->pView;
-    vkStream->putBe64(cgen_var_332);
+    uint64_t cgen_var_342 = (uint64_t)(uintptr_t)forMarshaling->pView;
+    vkStream->putBe64(cgen_var_342);
     if (forMarshaling->pView)
     {
         vkStream->write((const void*)forMarshaling->pView, sizeof(const uint8_t));
@@ -11651,8 +11779,8 @@
     if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
     {
         // WARNING PTR CHECK
-        uint64_t cgen_var_334 = (uint64_t)(uintptr_t)forMarshaling->pObjectName;
-        vkStream->putBe64(cgen_var_334);
+        uint64_t cgen_var_344 = (uint64_t)(uintptr_t)forMarshaling->pObjectName;
+        vkStream->putBe64(cgen_var_344);
         if (forMarshaling->pObjectName)
         {
             vkStream->putString(forMarshaling->pObjectName);
@@ -11714,8 +11842,8 @@
     vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
     vkStream->write((uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
     vkStream->write((uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
-    uint64_t cgen_var_336 = (uint64_t)forMarshaling->tagSize;
-    vkStream->putBe64(cgen_var_336);
+    uint64_t cgen_var_346 = (uint64_t)forMarshaling->tagSize;
+    vkStream->putBe64(cgen_var_346);
     vkStream->write((const void*)forMarshaling->pTag, forMarshaling->tagSize * sizeof(const uint8_t));
 }
 
@@ -11788,8 +11916,8 @@
     if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT)
     {
         // WARNING PTR CHECK
-        uint64_t cgen_var_338 = (uint64_t)(uintptr_t)forMarshaling->pMessageIdName;
-        vkStream->putBe64(cgen_var_338);
+        uint64_t cgen_var_348 = (uint64_t)(uintptr_t)forMarshaling->pMessageIdName;
+        vkStream->putBe64(cgen_var_348);
         if (forMarshaling->pMessageIdName)
         {
             vkStream->putString(forMarshaling->pMessageIdName);
@@ -11803,8 +11931,8 @@
     vkStream->putString(forMarshaling->pMessage);
     vkStream->write((uint32_t*)&forMarshaling->queueLabelCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_339 = (uint64_t)(uintptr_t)forMarshaling->pQueueLabels;
-    vkStream->putBe64(cgen_var_339);
+    uint64_t cgen_var_349 = (uint64_t)(uintptr_t)forMarshaling->pQueueLabels;
+    vkStream->putBe64(cgen_var_349);
     if (forMarshaling->pQueueLabels)
     {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i)
@@ -11814,8 +11942,8 @@
     }
     vkStream->write((uint32_t*)&forMarshaling->cmdBufLabelCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_340 = (uint64_t)(uintptr_t)forMarshaling->pCmdBufLabels;
-    vkStream->putBe64(cgen_var_340);
+    uint64_t cgen_var_350 = (uint64_t)(uintptr_t)forMarshaling->pCmdBufLabels;
+    vkStream->putBe64(cgen_var_350);
     if (forMarshaling->pCmdBufLabels)
     {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i)
@@ -11825,8 +11953,8 @@
     }
     vkStream->write((uint32_t*)&forMarshaling->objectCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_341 = (uint64_t)(uintptr_t)forMarshaling->pObjects;
-    vkStream->putBe64(cgen_var_341);
+    uint64_t cgen_var_351 = (uint64_t)(uintptr_t)forMarshaling->pObjects;
+    vkStream->putBe64(cgen_var_351);
     if (forMarshaling->pObjects)
     {
         for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i)
@@ -11932,11 +12060,11 @@
     vkStream->write((VkDebugUtilsMessengerCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
     vkStream->write((VkDebugUtilsMessageSeverityFlagsEXT*)&forMarshaling->messageSeverity, sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
     vkStream->write((VkDebugUtilsMessageTypeFlagsEXT*)&forMarshaling->messageType, sizeof(VkDebugUtilsMessageTypeFlagsEXT));
-    uint64_t cgen_var_346 = (uint64_t)forMarshaling->pfnUserCallback;
-    vkStream->putBe64(cgen_var_346);
+    uint64_t cgen_var_356 = (uint64_t)forMarshaling->pfnUserCallback;
+    vkStream->putBe64(cgen_var_356);
     // WARNING PTR CHECK
-    uint64_t cgen_var_347 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
-    vkStream->putBe64(cgen_var_347);
+    uint64_t cgen_var_357 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+    vkStream->putBe64(cgen_var_357);
     if (forMarshaling->pUserData)
     {
         vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
@@ -12127,9 +12255,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_350;
-    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_350, 1);
-    vkStream->write((uint64_t*)&cgen_var_350, 1 * 8);
+    uint64_t cgen_var_360;
+    vkStream->handleMapping()->mapHandles_VkDeviceMemory_u64(&forMarshaling->memory, &cgen_var_360, 1);
+    vkStream->write((uint64_t*)&cgen_var_360, 1 * 8);
 }
 
 void unmarshal_VkMemoryGetAndroidHardwareBufferInfoANDROID(
@@ -12145,9 +12273,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_351;
-    vkStream->read((uint64_t*)&cgen_var_351, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_351, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
+    uint64_t cgen_var_361;
+    vkStream->read((uint64_t*)&cgen_var_361, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkDeviceMemory(&cgen_var_361, (VkDeviceMemory*)&forUnmarshaling->memory, 1);
 }
 
 void marshal_VkExternalFormatANDROID(
@@ -12665,8 +12793,8 @@
     vkStream->write((VkBool32*)&forMarshaling->coverageModulationTableEnable, sizeof(VkBool32));
     vkStream->write((uint32_t*)&forMarshaling->coverageModulationTableCount, sizeof(uint32_t));
     // WARNING PTR CHECK
-    uint64_t cgen_var_352 = (uint64_t)(uintptr_t)forMarshaling->pCoverageModulationTable;
-    vkStream->putBe64(cgen_var_352);
+    uint64_t cgen_var_362 = (uint64_t)(uintptr_t)forMarshaling->pCoverageModulationTable;
+    vkStream->putBe64(cgen_var_362);
     if (forMarshaling->pCoverageModulationTable)
     {
         vkStream->write((const float*)forMarshaling->pCoverageModulationTable, forMarshaling->coverageModulationTableCount * sizeof(const float));
@@ -12722,8 +12850,8 @@
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
     vkStream->write((VkValidationCacheCreateFlagsEXT*)&forMarshaling->flags, sizeof(VkValidationCacheCreateFlagsEXT));
-    uint64_t cgen_var_354 = (uint64_t)forMarshaling->initialDataSize;
-    vkStream->putBe64(cgen_var_354);
+    uint64_t cgen_var_364 = (uint64_t)forMarshaling->initialDataSize;
+    vkStream->putBe64(cgen_var_364);
     vkStream->write((const void*)forMarshaling->pInitialData, forMarshaling->initialDataSize * sizeof(const uint8_t));
 }
 
@@ -12757,9 +12885,9 @@
         vkStream->write((const void*)forMarshaling->pNext, sizeof(VkStructureType));
         marshal_extension_struct(vkStream, forMarshaling->pNext);
     }
-    uint64_t cgen_var_356;
-    vkStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&forMarshaling->validationCache, &cgen_var_356, 1);
-    vkStream->write((uint64_t*)&cgen_var_356, 1 * 8);
+    uint64_t cgen_var_366;
+    vkStream->handleMapping()->mapHandles_VkValidationCacheEXT_u64(&forMarshaling->validationCache, &cgen_var_366, 1);
+    vkStream->write((uint64_t*)&cgen_var_366, 1 * 8);
 }
 
 void unmarshal_VkShaderModuleValidationCacheCreateInfoEXT(
@@ -12775,9 +12903,9 @@
         vkStream->read((void*)(&pNext_placeholder), sizeof(VkStructureType));
         unmarshal_extension_struct(vkStream, (void*)(forUnmarshaling->pNext));
     }
-    uint64_t cgen_var_357;
-    vkStream->read((uint64_t*)&cgen_var_357, 1 * 8);
-    vkStream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_357, (VkValidationCacheEXT*)&forUnmarshaling->validationCache, 1);
+    uint64_t cgen_var_367;
+    vkStream->read((uint64_t*)&cgen_var_367, 1 * 8);
+    vkStream->handleMapping()->mapHandles_u64_VkValidationCacheEXT(&cgen_var_367, (VkValidationCacheEXT*)&forUnmarshaling->validationCache, 1);
 }
 
 #endif
@@ -13074,8 +13202,8 @@
     }
     vkStream->write((VkExternalMemoryHandleTypeFlagBits*)&forMarshaling->handleType, sizeof(VkExternalMemoryHandleTypeFlagBits));
     // WARNING PTR CHECK
-    uint64_t cgen_var_358 = (uint64_t)(uintptr_t)forMarshaling->pHostPointer;
-    vkStream->putBe64(cgen_var_358);
+    uint64_t cgen_var_368 = (uint64_t)(uintptr_t)forMarshaling->pHostPointer;
+    vkStream->putBe64(cgen_var_368);
     if (forMarshaling->pHostPointer)
     {
         vkStream->write((void*)forMarshaling->pHostPointer, sizeof(uint8_t));
@@ -13369,8 +13497,8 @@
     }
     vkStream->write((VkPipelineStageFlagBits*)&forMarshaling->stage, sizeof(VkPipelineStageFlagBits));
     // WARNING PTR CHECK
-    uint64_t cgen_var_360 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
-    vkStream->putBe64(cgen_var_360);
+    uint64_t cgen_var_370 = (uint64_t)(uintptr_t)forMarshaling->pCheckpointMarker;
+    vkStream->putBe64(cgen_var_370);
     if (forMarshaling->pCheckpointMarker)
     {
         vkStream->write((void*)forMarshaling->pCheckpointMarker, sizeof(uint8_t));
diff --git a/system/vulkan_enc/goldfish_vk_private_defs.h b/system/vulkan_enc/goldfish_vk_private_defs.h
index 21eb730..b967d89 100644
--- a/system/vulkan_enc/goldfish_vk_private_defs.h
+++ b/system/vulkan_enc/goldfish_vk_private_defs.h
@@ -17,6 +17,7 @@
 #include <vulkan/vulkan.h>
 
 #ifdef __cplusplus
+#include <algorithm>
 extern "C" {
 #endif
 
@@ -534,9 +535,20 @@
 
 // VulkanStream features
 #define VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT (1 << 0)
+#define VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT (1 << 1)
 
 #define VK_YCBCR_CONVERSION_DO_NOTHING ((VkSamplerYcbcrConversion)0x1111111111111111)
 
 #ifdef __cplusplus
 } // extern "C"
 #endif
+
+#ifdef __cplusplus
+
+template<class T, typename F>
+bool arrayany(const T* arr, uint32_t begin, uint32_t end, const F& func) {
+    const T* e = arr + end;
+    return std::find_if(arr + begin, e, func) != e;
+}
+
+#endif